typesea 0.1.0 → 0.3.0

package/docs/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta
       name="description"
-      content="TypeSea documentation: zero-dependency TypeScript runtime narrowing with cached Sea-of-Nodes validation plans, runtime compilation, and AOT emission."
+      content="TypeSea documentation: complete README, API reference, and engine notes for zero-dependency TypeScript runtime validation."
     >
     <title>TypeSea Docs</title>
     <style>
@@ -29,7 +29,6 @@
         --code-comment: #8b98a9;
         --sidebar-bg: #1d2422;
         --sidebar-ink: #e9efe9;
-        --sidebar-muted: #9fae a5;
         --sidebar-muted: #9faea5;
         --sidebar-line: rgba(233, 239, 233, 0.12);
         --shadow: 0 10px 30px rgba(28, 36, 34, 0.07);
@@ -70,16 +69,9 @@
         margin: 0;
         background: var(--bg);
         color: var(--ink);
-        font-family:
-          ui-sans-serif,
-          system-ui,
-          -apple-system,
-          "Segoe UI",
-          Roboto,
-          "Helvetica Neue",
-          sans-serif;
+        font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", sans-serif;
         font-size: 15px;
-        line-height: 1.6;
+        line-height: 1.62;
       }
 
       a {
@@ -89,13 +81,7 @@
 
       code,
       pre {
-        font-family:
-          ui-monospace,
-          "SFMono-Regular",
-          Menlo,
-          Consolas,
-          "Liberation Mono",
-          monospace;
+        font-family: ui-monospace, "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace;
       }
 
       p code,
@@ -107,12 +93,18 @@
         font-size: 0.92em;
       }
 
-      /* ---------- shell ---------- */
+      .language-radio {
+        position: absolute;
+        width: 1px;
+        height: 1px;
+        opacity: 0;
+        pointer-events: none;
+      }
 
       .shell {
         display: grid;
         min-height: 100vh;
-        grid-template-columns: 264px minmax(0, 1fr);
+        grid-template-columns: 284px minmax(0, 1fr);
       }
 
       .sidebar {
@@ -138,7 +130,6 @@
         margin: 0;
         font-size: 22px;
         line-height: 1;
-        letter-spacing: -0.01em;
       }
 
       .brand .version {
@@ -156,37 +147,11 @@
         border-bottom: 1px solid var(--sidebar-line);
         color: var(--sidebar-muted);
         font-size: 12.5px;
-        line-height: 1.5;
-      }
-
-      .search {
-        padding: 16px 16px 8px;
-      }
-
-      .search input {
-        width: 100%;
-        min-height: 36px;
-        border: 1px solid var(--sidebar-line);
-        border-radius: 8px;
-        padding: 0 12px;
-        background: rgba(255, 255, 255, 0.06);
-        color: var(--sidebar-ink);
-        font: inherit;
-        font-size: 13px;
-        outline: none;
-      }
-
-      .search input:focus {
-        border-color: #46b48f;
-      }
-
-      .search input::placeholder {
-        color: var(--sidebar-muted);
       }
 
       .nav {
         flex: 1;
-        padding: 6px 12px 18px;
+        padding: 8px 12px 18px;
       }
 
       .nav-group {
@@ -202,14 +167,14 @@
       .nav a {
         display: flex;
         align-items: center;
-        min-height: 33px;
+        min-height: 32px;
         border-left: 2px solid transparent;
         border-radius: 0 7px 7px 0;
         margin: 1px 0;
         padding: 5px 12px;
         color: var(--sidebar-ink);
-        opacity: 0.82;
-        font-size: 13.5px;
+        opacity: 0.84;
+        font-size: 13px;
       }
 
       .nav a:hover,
@@ -218,13 +183,6 @@
         opacity: 1;
       }
 
-      .nav a.active {
-        border-left-color: #34c496;
-        background: rgba(52, 196, 150, 0.1);
-        color: #9ce8cd;
-        opacity: 1;
-      }
-
       .sidebar-foot {
         padding: 14px 22px 20px;
         border-top: 1px solid var(--sidebar-line);
@@ -232,8 +190,6 @@
         font-size: 12px;
       }
 
-      /* ---------- content ---------- */
-
       .content {
         min-width: 0;
       }
@@ -263,13 +219,17 @@
         font-weight: 650;
       }
 
+      .topbar-actions,
       .topbar-links {
         display: flex;
+        align-items: center;
         flex-wrap: wrap;
+        justify-content: flex-end;
         gap: 8px;
       }
 
-      .topbar-links a {
+      .topbar-links a,
+      .language-switch label {
         border: 1px solid var(--line);
         border-radius: 7px;
         padding: 5px 11px;
@@ -278,31 +238,58 @@
         font-size: 12.5px;
       }
 
-      .topbar-links a:hover {
+      .language-switch {
+        display: inline-flex;
+        gap: 4px;
+      }
+
+      .language-switch label {
+        cursor: pointer;
+        font-weight: 700;
+      }
+
+      #language-en:checked ~ .shell label[for="language-en"],
+      #language-ko:checked ~ .shell label[for="language-ko"] {
         border-color: var(--accent);
+        background: var(--accent-soft);
         color: var(--accent-ink);
       }
 
+      .locale-ko,
+      .i18n-ko {
+        display: none;
+      }
+
+      #language-ko:checked ~ .shell .locale-en,
+      #language-ko:checked ~ .shell .i18n-en {
+        display: none;
+      }
+
+      #language-ko:checked ~ .shell .locale-ko {
+        display: block;
+      }
+
+      #language-ko:checked ~ .shell .i18n-ko {
+        display: inline;
+      }
+
       main {
-        max-width: 880px;
+        max-width: 980px;
         margin: 0 auto;
-        padding: 40px 34px 80px;
+        padding: 40px 34px 84px;
       }
 
-      section {
-        padding: 30px 0 34px;
+      section,
+      article.source-doc {
+        padding: 30px 0 36px;
         border-bottom: 1px solid var(--line);
-        scroll-margin-top: 72px;
+        scroll-margin-top: 74px;
       }
 
       section:first-child {
         padding-top: 0;
       }
 
-      section:last-child {
-        border-bottom: 0;
-      }
-
       .eyebrow {
         margin: 0 0 6px;
         color: var(--accent);
@@ -314,72 +301,46 @@
 
       h2 {
         margin: 0 0 10px;
-        font-size: 25px;
+        font-size: 26px;
         line-height: 1.2;
-        letter-spacing: -0.01em;
       }
 
       h3 {
-        margin: 0 0 8px;
-        font-size: 16px;
+        margin: 24px 0 8px;
+        font-size: 18px;
         line-height: 1.3;
       }
 
+      h4 {
+        margin: 20px 0 8px;
+        font-size: 15px;
+      }
+
       p {
         margin: 0 0 12px;
       }
 
       .lede {
-        max-width: 720px;
+        max-width: 760px;
         margin-bottom: 16px;
         color: var(--muted);
         font-size: 15.5px;
       }
 
-      /* ---------- components ---------- */
-
       .hero {
         display: grid;
-        grid-template-columns: minmax(0, 1fr) 300px;
+        grid-template-columns: minmax(0, 1fr) 310px;
         gap: 28px;
         align-items: start;
       }
 
-      .checklist {
-        display: grid;
-        gap: 8px;
-        margin: 16px 0 0;
-        padding: 0;
-        list-style: none;
-      }
-
-      .checklist li {
-        position: relative;
-        padding-left: 24px;
-        color: var(--muted);
-        font-size: 14px;
-      }
-
-      .checklist li::before {
-        position: absolute;
-        left: 0;
-        top: 1px;
-        color: var(--accent);
-        font-weight: 700;
-        content: "✓";
-      }
-
-      .checklist li strong {
-        color: var(--ink);
-        font-weight: 600;
-      }
-
-      .status-panel {
+      .status-panel,
+      .tile,
+      .admonition {
         border: 1px solid var(--line);
         border-radius: 10px;
         background: var(--surface);
         box-shadow: var(--shadow);
-        overflow: hidden;
       }
 
       .status-panel header {
@@ -410,76 +371,13 @@
         align-items: center;
         border-radius: 999px;
         padding: 2px 9px;
+        background: var(--accent-soft);
+        color: var(--accent-ink);
         font-size: 11.5px;
         font-weight: 700;
         white-space: nowrap;
       }
 
-      .pill.green {
-        background: var(--accent-soft);
-        color: var(--accent-ink);
-      }
-
-      .pill.amber {
-        background: var(--amber-soft);
-        color: var(--amber);
-      }
-
-      .pill.violet {
-        background: var(--violet-soft);
-        color: var(--violet);
-      }
-
-      .callout {
-        display: grid;
-        grid-template-columns: auto minmax(0, 1fr);
-        gap: 10px;
-        margin: 16px 0 0;
-        border: 1px solid var(--line);
-        border-left: 3px solid var(--accent);
-        border-radius: 8px;
-        padding: 12px 14px;
-        background: var(--surface);
-        font-size: 13.5px;
-      }
-
-      .callout.warn {
-        border-left-color: var(--amber);
-      }
-
-      .callout .icon {
-        font-size: 15px;
-        line-height: 1.5;
-      }
-
-      .callout p {
-        margin: 0;
-        color: var(--muted);
-      }
-
-      .callout strong {
-        color: var(--ink);
-      }
-
-      .code-block {
-        margin: 16px 0 0;
-        border-radius: 10px;
-        overflow-x: auto;
-        background: var(--code-bg);
-        color: var(--code-ink);
-      }
-
-      .code-block pre {
-        margin: 0;
-        padding: 16px 18px;
-        font-size: 13px;
-        line-height: 1.6;
-      }
-
-      .code-block .cm {
-        color: var(--code-comment);
-      }
-
       .grid {
         display: grid;
         grid-template-columns: repeat(3, minmax(0, 1fr));
@@ -492,10 +390,12 @@
       }
 
       .tile {
-        border: 1px solid var(--line);
-        border-radius: 10px;
         padding: 15px 16px;
-        background: var(--surface);
+      }
+
+      .tile h3 {
+        margin-top: 0;
+        font-size: 14.5px;
       }
 
       .tile p {
@@ -504,74 +404,70 @@
         font-size: 13px;
       }
 
-      .tile > code,
-      .tile code a {
-        display: inline-block;
-        border-radius: 6px;
-        padding: 2px 7px;
-        background: var(--surface-2);
-        color: var(--accent-ink);
-        font-size: 12.5px;
+      .checklist {
+        display: grid;
+        gap: 8px;
+        margin: 16px 0 0;
+        padding: 0;
+        list-style: none;
       }
 
-      .tile h3 {
-        font-size: 14.5px;
+      .checklist li {
+        position: relative;
+        padding-left: 24px;
+        color: var(--muted);
+        font-size: 14px;
       }
 
-      .pipeline {
-        display: grid;
-        grid-template-columns: repeat(5, minmax(0, 1fr));
-        gap: 10px;
-        margin-top: 18px;
-        counter-reset: stage;
+      .checklist li::before {
+        position: absolute;
+        left: 0;
+        top: 1px;
+        color: var(--accent);
+        font-weight: 700;
+        content: "✓";
       }
 
-      .stage {
-        position: relative;
-        border: 1px solid var(--line);
-        border-top: 3px solid var(--accent);
-        border-radius: 9px;
-        padding: 12px 13px 11px;
-        background: var(--surface);
-        counter-increment: stage;
+      .doc-content a {
+        color: var(--accent-ink);
+        text-decoration: underline;
+        text-underline-offset: 2px;
       }
 
-      .stage.alt {
-        border-top-color: var(--violet);
+      .doc-content ul,
+      .doc-content ol {
+        margin: 0 0 14px;
+        padding-left: 24px;
       }
 
-      .stage::before {
-        display: block;
-        margin-bottom: 4px;
-        color: var(--muted);
-        font-size: 10.5px;
-        font-weight: 700;
-        letter-spacing: 0.06em;
-        content: "STEP " counter(stage);
+      .doc-content li {
+        margin: 4px 0;
       }
 
-      .stage strong {
-        display: block;
-        margin-bottom: 4px;
-        font-size: 13.5px;
+      .code-block,
+      .doc-content pre {
+        margin: 16px 0;
+        border-radius: 10px;
+        overflow-x: auto;
+        background: var(--code-bg);
+        color: var(--code-ink);
       }
 
-      .stage span {
-        color: var(--muted);
-        font-size: 12px;
-        line-height: 1.5;
-        display: block;
+      .code-block pre,
+      .doc-content pre {
+        padding: 16px 18px;
+        font-size: 13px;
+        line-height: 1.6;
       }
 
-      .consumers {
-        display: grid;
-        grid-template-columns: repeat(3, minmax(0, 1fr));
-        gap: 12px;
-        margin-top: 12px;
+      .doc-content pre code {
+        background: transparent;
+        padding: 0;
+        color: inherit;
       }
 
       .table-wrap {
-        margin-top: 16px;
+        margin: 16px 0;
         border: 1px solid var(--line);
         border-radius: 10px;
         background: var(--surface);
@@ -594,11 +490,11 @@
 
       th {
         background: var(--surface-2);
+        color: var(--muted);
         font-size: 12px;
         font-weight: 700;
         letter-spacing: 0.03em;
         text-transform: uppercase;
-        color: var(--muted);
         white-space: nowrap;
       }
 
@@ -606,34 +502,59 @@
         border-bottom: 0;
       }
 
-      td.num {
-        font-variant-numeric: tabular-nums;
-        text-align: right;
-        white-space: nowrap;
+      .admonition {
+        margin: 16px 0;
+        border-left: 3px solid var(--accent);
+        padding: 13px 15px;
+        box-shadow: none;
       }
 
-      th.num {
-        text-align: right;
+      .admonition.warning,
+      .admonition.caution {
+        border-left-color: var(--amber);
       }
 
-      td .best {
-        color: var(--accent-ink);
-        font-weight: 700;
+      .admonition-title {
+        display: block;
+        margin-bottom: 5px;
+        color: var(--ink);
+        font-size: 13px;
+        font-weight: 750;
       }
 
-      .footnote {
-        margin-top: 10px;
+      .admonition p:last-child {
+        margin-bottom: 0;
+      }
+
+      .source-doc > header {
+        margin-bottom: 18px;
+      }
+
+      .source-doc > header p {
         color: var(--muted);
-        font-size: 12.5px;
+        font-size: 13.5px;
       }
 
-      .hidden {
-        display: none;
+      .benchmark-image {
+        display: block;
+        max-width: 100%;
+        height: auto;
+        margin: 16px 0;
+        border-radius: 10px;
       }
 
-      /* ---------- responsive ---------- */
+      .muted-link {
+        color: var(--muted);
+      }
+
+      hr {
+        height: 1px;
+        border: 0;
+        margin: 28px 0;
+        background: var(--line);
+      }
 
-      @media (max-width: 960px) {
+      @media (max-width: 980px) {
         .shell {
           grid-template-columns: 1fr;
         }
@@ -648,16 +569,12 @@
         }
 
         .grid,
-        .consumers {
-          grid-template-columns: repeat(2, minmax(0, 1fr));
-        }
-
-        .pipeline {
+        .grid.two {
           grid-template-columns: repeat(2, minmax(0, 1fr));
         }
       }
 
-      @media (max-width: 620px) {
+      @media (max-width: 640px) {
         .topbar {
           position: static;
           flex-direction: column;
@@ -665,118 +582,195 @@
           padding: 12px 18px;
         }
 
-        main {
-          padding: 28px 18px 56px;
+        .topbar-actions {
+          justify-content: flex-start;
         }
 
-        h2 {
-          font-size: 22px;
+        main {
+          padding: 28px 18px 56px;
         }
 
         .grid,
-        .grid.two,
-        .consumers,
-        .pipeline {
+        .grid.two {
           grid-template-columns: 1fr;
         }
       }
     </style>
   </head>
   <body>
+    <input class="language-radio" type="radio" name="docs-language" id="language-en" checked>
+    <input class="language-radio" type="radio" name="docs-language" id="language-ko">
     <div class="shell">
       <aside class="sidebar" aria-label="Documentation navigation">
         <div class="brand">
           <h1>TypeSea</h1>
-          <span class="version">v0.1.0</span>
+          <span class="version">v0.3.0</span>
         </div>
         <p class="brand-tagline">
-          Zero-dependency runtime narrowing for TypeScript.
-          ESM-only &middot; Node &ge; 20.19 &middot; MIT
+          <span class="i18n-en">Complete docs from README.md, docs/api.md, and docs/engine-notes.md.</span>
+          <span class="i18n-ko" lang="ko">README, API 레퍼런스, 엔진 노트를 한 곳에 모은 문서입니다.</span>
         </p>
-        <div class="search">
-          <input data-search type="search" placeholder="Filter sections&hellip;" aria-label="Filter documentation sections">
-        </div>
         <nav class="nav">
-          <p class="nav-group">Guide</p>
-          <a href="#overview">Overview</a>
-          <a href="#quick-start">Quick start</a>
-          <a href="#semantics">Semantics</a>
-          <p class="nav-group">Internals</p>
-          <a href="#architecture">Architecture</a>
-          <a href="#api">API map</a>
-          <a href="#adapters">Adapters</a>
-          <p class="nav-group">Quality</p>
-          <a href="#benchmarks">Benchmarks</a>
-          <a href="#release">Release gate</a>
-          <a href="#files">Reference files</a>
+          <p class="nav-group">
+            <span class="i18n-en">Start</span>
+            <span class="i18n-ko" lang="ko">시작</span>
+          </p>
+          <a href="#overview">
+            <span class="i18n-en">Overview</span>
+            <span class="i18n-ko" lang="ko">개요</span>
+          </a>
+          <a href="#quick-start">
+            <span class="i18n-en">Quick start</span>
+            <span class="i18n-ko" lang="ko">빠른 시작</span>
+          </a>
+          <a href="#architecture">
+            <span class="i18n-en">Architecture</span>
+            <span class="i18n-ko" lang="ko">아키텍처</span>
+          </a>
+          <a href="#api">
+            <span class="i18n-en">API map</span>
+            <span class="i18n-ko" lang="ko">API 지도</span>
+          </a>
+          <a href="#adapters">
+            <span class="i18n-en">Adapters</span>
+            <span class="i18n-ko" lang="ko">어댑터</span>
+          </a>
+          <a href="#benchmarks">
+            <span class="i18n-en">Benchmarks</span>
+            <span class="i18n-ko" lang="ko">벤치마크</span>
+          </a>
+          <a href="#release">
+            <span class="i18n-en">Release gate</span>
+            <span class="i18n-ko" lang="ko">릴리스 게이트</span>
+          </a>
+          <a href="#files">
+            <span class="i18n-en">Source files</span>
+            <span class="i18n-ko" lang="ko">원본 파일</span>
+          </a>
+          <p class="nav-group">
+            <span class="i18n-en">Full Documents</span>
+            <span class="i18n-ko" lang="ko">전체 문서</span>
+          </p>
+          <a href="#readme">README</a>
+          <a href="#api-reference">
+            <span class="i18n-en">API Reference</span>
+            <span class="i18n-ko" lang="ko">API 레퍼런스</span>
+          </a>
+          <a href="#engine-notes">
+            <span class="i18n-en">Engine Notes</span>
+            <span class="i18n-ko" lang="ko">엔진 노트</span>
+          </a>
         </nav>
-        <p class="sidebar-foot">MIT License &middot; zero runtime dependencies</p>
+        <p class="sidebar-foot">
+          <span class="i18n-en">MIT License &middot; zero runtime dependencies</span>
+          <span class="i18n-ko" lang="ko">MIT License &middot; 런타임 의존성 없음</span>
+        </p>
       </aside>
 
       <div class="content">
         <div class="topbar">
-          <span class="topbar-crumb"><strong>TypeSea</strong> / Documentation</span>
-          <div class="topbar-links">
-            <a href="https://github.com/Feralthedogg/TypeSea">GitHub</a>
-            <a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/api.md">API reference</a>
-            <a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/engine-notes.md">Engine notes</a>
+          <span class="topbar-crumb">
+            <strong>TypeSea</strong> /
+            <span class="i18n-en">Documentation</span>
+            <span class="i18n-ko" lang="ko">문서</span>
+          </span>
+          <div class="topbar-actions">
+            <div class="language-switch" aria-label="Documentation language">
+              <label for="language-en">EN</label>
+              <label for="language-ko">한국어</label>
+            </div>
+            <div class="topbar-links">
+              <a href="https://github.com/Feralthedogg/TypeSea">GitHub</a>
+              <a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/api.md">
+                <span class="i18n-en">API reference</span>
+                <span class="i18n-ko" lang="ko">API 레퍼런스</span>
+              </a>
+              <a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/engine-notes.md">
+                <span class="i18n-en">Engine notes</span>
+                <span class="i18n-ko" lang="ko">엔진 노트</span>
+              </a>
+            </div>
           </div>
         </div>
 
         <main>
-          <section id="overview" data-doc-section data-title="overview contract zero dependency esm result frozen">
+          <section id="overview" data-doc-section>
             <div class="hero">
               <div>
-                <p class="eyebrow">Overview</p>
-                <h2>Runtime typeguards shaped like a small compiler.</h2>
+                <p class="eyebrow">
+                  <span class="i18n-en">Overview</span>
+                  <span class="i18n-ko" lang="ko">개요</span>
+                </p>
+                <h2>
+                  <span class="i18n-en">Zero-dependency TypeScript validation with compiled type guards.</span>
+                  <span class="i18n-ko" lang="ko">컴파일된 타입 가드까지 제공하는, 런타임 의존성 없는 TypeScript 검증 라이브러리.</span>
+                </h2>
                 <p class="lede">
-                  TypeSea treats validation schemas as frontend syntax. Each guard lowers into a
-                  cached validation plan &mdash; a schema-specialized predicate kernel plus an
-                  optimized graph &mdash; and executes through the plan, a runtime-compiled
-                  validator, or a standalone AOT module.
+                  <span class="i18n-en">TypeSea turns immutable schemas into runtime guards, compiled validators, AOT modules, JSON Schema exports, framework adapters, and frozen diagnostic Result values.</span>
+                  <span class="i18n-ko" lang="ko">TypeSea는 불변 스키마를 런타임 가드, 컴파일된 검증기, AOT 모듈, JSON Schema 출력, 프레임워크 어댑터, 동결된 진단 Result로 연결합니다.</span>
                 </p>
                 <ul class="checklist">
-                  <li><strong>Zero dependencies</strong> &mdash; no runtime, peer, optional, or bundled packages, enforced by policy.</li>
-                  <li><strong>Hostile-input safe</strong> &mdash; descriptor reads mean user getters never execute.</li>
-                  <li><strong>Result-first</strong> &mdash; expected failures return frozen <code>Result</code> values, never <code>throw</code>.</li>
-                  <li><strong>Allocation-aware</strong> &mdash; successful <code>is()</code> avoids diagnostic allocation.</li>
-                  <li><strong>No escape hatches</strong> &mdash; <code>any</code>, <code>try</code>, and <code>catch</code> are banned from the codebase.</li>
+                  <li>
+                    <span class="i18n-en"><strong>Zero dependencies</strong> &mdash; enforced before release.</span>
+                    <span class="i18n-ko" lang="ko"><strong>의존성 없음</strong> &mdash; 릴리스 전에 정책 게이트로 강제합니다.</span>
+                  </li>
+                  <li>
+                    <span class="i18n-en"><strong>Safe by default</strong> &mdash; descriptor reads avoid getter execution.</span>
+                    <span class="i18n-ko" lang="ko"><strong>기본값은 안전 모드</strong> &mdash; descriptor read로 getter 실행을 피합니다.</span>
+                  </li>
+                  <li>
+                    <span class="i18n-en"><strong>Fast when trusted</strong> &mdash; unsafe and unchecked modes trade hardening for direct reads.</span>
+                    <span class="i18n-ko" lang="ko"><strong>신뢰된 데이터에서는 빠르게</strong> &mdash; unsafe/unchecked 모드는 일부 방어를 direct read 성능과 맞바꿉니다.</span>
+                  </li>
+                  <li>
+                    <span class="i18n-en"><strong>Complete references</strong> &mdash; README, API reference, and engine notes are rendered below.</span>
+                    <span class="i18n-ko" lang="ko"><strong>문서 전체 포함</strong> &mdash; README, API 레퍼런스, 엔진 노트 전문을 아래에서 볼 수 있습니다.</span>
+                  </li>
                 </ul>
               </div>
               <aside class="status-panel" aria-label="Package status">
-                <header>Package status</header>
+                <header>
+                  <span class="i18n-en">Package status</span>
+                  <span class="i18n-ko" lang="ko">패키지 상태</span>
+                </header>
                 <div class="status-row">
-                  <span>Runtime dependencies</span>
-                  <span class="pill green">zero</span>
+                  <span>
+                    <span class="i18n-en">Runtime dependencies</span>
+                    <span class="i18n-ko" lang="ko">런타임 의존성</span>
+                  </span>
+                  <span class="pill">zero</span>
                 </div>
                 <div class="status-row">
-                  <span>Execution engines</span>
-                  <span class="pill green">plan &middot; jit &middot; aot</span>
+                  <span>
+                    <span class="i18n-en">Execution paths</span>
+                    <span class="i18n-ko" lang="ko">실행 경로</span>
+                  </span>
+                  <span class="pill">plan &middot; jit &middot; aot</span>
                 </div>
                 <div class="status-row">
-                  <span>Module format</span>
-                  <span class="pill violet">ESM-only</span>
+                  <span>
+                    <span class="i18n-en">Module format</span>
+                    <span class="i18n-ko" lang="ko">모듈 형식</span>
+                  </span>
+                  <span class="pill">ESM-only</span>
                 </div>
                 <div class="status-row">
                   <span>Node.js</span>
-                  <span class="pill green">&ge; 20.19</span>
-                </div>
-                <div class="status-row">
-                  <span>Adapters</span>
-                  <span class="pill amber">structural</span>
+                  <span class="pill">&ge; 20.19</span>
                 </div>
               </aside>
             </div>
           </section>
 
-          <section id="quick-start" data-doc-section data-title="quick start install guard compile check json schema csp">
-            <p class="eyebrow">Quick start</p>
-            <h2>Define a guard once, then choose the execution path.</h2>
-            <p class="lede">
-              The same guard narrows through <code>is()</code>, returns immutable diagnostics
-              through <code>check()</code>, exports lossless JSON Schema, or compiles into a
-              generated validator.
+          <section id="quick-start" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Quick start</span>
+              <span class="i18n-ko" lang="ko">빠른 시작</span>
             </p>
+            <h2>
+              <span class="i18n-en">Install, define, narrow, compile.</span>
+              <span class="i18n-ko" lang="ko">설치하고, 스키마를 정의하고, 타입을 좁힌 뒤, 필요한 곳만 컴파일하세요.</span>
+            </h2>
             <div class="code-block">
               <pre><code>npm install typesea</code></pre>
             </div>
@@ -791,452 +785,1096 @@ const User = t.strictObject({
 
 type User = Infer&lt;typeof User&gt;;
 
-<span class="cm">// 1) Boolean narrowing &mdash; no diagnostic allocation on success</span>
 if (User.is(input)) {
-  input.id; <span class="cm">// narrowed</span>
+  input.id;
 }
 
-<span class="cm">// 2) Immutable diagnostics &mdash; frozen Result, never throws</span>
 const checked = User.check(input);
-
-<span class="cm">// 3) Hot path &mdash; generated validator code</span>
 const FastUser = compile(User, { name: "isUser" });
-
-<span class="cm">// 4) Interop &mdash; lossless-only JSON Schema export</span>
 const schema = toJsonSchema(User);</code></pre>
             </div>
-            <div class="callout warn">
-              <span class="icon">&#9888;</span>
-              <p>
-                <strong><code>compile()</code> uses <code>new Function</code></strong>, which throws under a
-                Content-Security-Policy that forbids <code>unsafe-eval</code>. In CSP-restricted
-                environments, emit validator source ahead of time with <code>emitAotModule()</code>.
-              </p>
-            </div>
           </section>
 
-          <section id="semantics" data-doc-section data-title="semantics presence optional undefinedable nullable edge nan proto uuid strict">
-            <p class="eyebrow">Semantics</p>
-            <h2>Explicit presence, deliberate edge behavior.</h2>
-            <p class="lede">
-              Object presence is a first-class concept, and edge cases that break typical
-              validators are deliberate, documented decisions pinned by tests.
+          <section id="architecture" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Architecture</span>
+              <span class="i18n-ko" lang="ko">아키텍처</span>
             </p>
-            <div class="table-wrap">
-              <table>
-                <thead>
-                  <tr>
-                    <th>Wrapper</th>
-                    <th>Key may be absent</th>
-                    <th>Value may be <code>undefined</code></th>
-                    <th>Inferred type</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  <tr>
-                    <td><code>t.optional(inner)</code></td>
-                    <td>yes</td>
-                    <td>no</td>
-                    <td><code>key?: T</code></td>
-                  </tr>
-                  <tr>
-                    <td><code>t.undefinedable(inner)</code></td>
-                    <td>no</td>
-                    <td>yes</td>
-                    <td><code>key: T | undefined</code></td>
-                  </tr>
-                  <tr>
-                    <td><code>t.nullable(inner)</code></td>
-                    <td>&mdash;</td>
-                    <td>value may be <code>null</code></td>
-                    <td><code>key: T | null</code></td>
-                  </tr>
-                </tbody>
-              </table>
-            </div>
-            <div class="table-wrap">
-              <table>
-                <thead>
-                  <tr>
-                    <th>Input</th>
-                    <th>Behavior</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  <tr>
-                    <td><code>NaN</code>, <code>Infinity</code></td>
-                    <td><code>t.number</code> accepts finite numbers only; <code>t.literal(NaN)</code> matches <code>NaN</code> via <code>Object.is</code>.</td>
-                  </tr>
-                  <tr>
-                    <td>Getter-backed properties</td>
-                    <td>Never executed &mdash; reads go through descriptors, accessors count as missing data.</td>
-                  </tr>
-                  <tr>
-                    <td><code>__proto__</code>, <code>constructor</code> keys</td>
-                    <td>Validated as plain own keys through null-prototype lookups; no pollution.</td>
-                  </tr>
-                  <tr>
-                    <td>Strict-object extras</td>
-                    <td>Rejected via <code>Reflect.ownKeys</code> &mdash; including symbol keys and non-enumerable properties.</td>
-                  </tr>
-                  <tr>
-                    <td>Sparse array holes</td>
-                    <td>Read as <code>undefined</code> without executing accessors.</td>
-                  </tr>
-                  <tr>
-                    <td>Global-flag regexes</td>
-                    <td>Cloned at construction; <code>lastIndex</code> reset before every test.</td>
-                  </tr>
-                  <tr>
-                    <td>UUID strings</td>
-                    <td>RFC 9562 versions 1&ndash;8 plus the nil UUID.</td>
-                  </tr>
-                  <tr>
-                    <td>Cyclic input values</td>
-                    <td>Validate finitely via (value &times; schema) active-pair tracking.</td>
-                  </tr>
-                  <tr>
-                    <td>Nesting depth</td>
-                    <td>Capped at 1024 frames &mdash; deep input fails instead of overflowing the stack.</td>
-                  </tr>
-                </tbody>
-              </table>
-            </div>
-          </section>
-
-          <section id="architecture" data-doc-section data-title="architecture sea of nodes ir lower optimize plan kernel graph codegen">
-            <p class="eyebrow">Architecture</p>
-            <h2>Every schema lowers into a cached validation plan.</h2>
+            <h2>
+              <span class="i18n-en">Builder -> frozen schema -> Sea-of-Nodes validation IR -> optimize -> validation plan.</span>
+              <span class="i18n-ko" lang="ko">빌더 -> 동결된 스키마 -> Sea-of-Nodes 검증 IR -> 최적화 -> 검증 계획.</span>
+            </h2>
             <p class="lede">
-              The public schema tree is kept for builder validation and diagnostics. Each schema
-              identity lowers once into the Sea-of-Nodes validation IR, is optimized, and is cached
-              as a validation plan owning both a schema-specialized predicate kernel and the
-              optimized graph consumed by generated validators.
+              <span class="i18n-en">The graph is the source for generated validators, while the plan-owned kernel keeps ordinary guard execution out of a generic node interpreter.</span>
+              <span class="i18n-ko" lang="ko">그래프는 생성 검증기의 원본이고, 계획이 소유한 커널은 일반 가드 실행이 범용 노드 인터프리터를 거치지 않게 합니다.</span>
             </p>
-            <div class="pipeline" aria-label="TypeSea validation pipeline">
-              <div class="stage">
-                <strong>Builder</strong>
-                <span>Immutable guards validate construction inputs up front.</span>
-              </div>
-              <div class="stage">
-                <strong>Frozen schema</strong>
-                <span>The tree stores semantics and diagnostic structure.</span>
-              </div>
-              <div class="stage alt">
-                <strong>Sea-of-Nodes IR</strong>
-                <span>Lowering shares loads, predicates, keysets, and discriminant dispatch.</span>
-              </div>
-              <div class="stage alt">
-                <strong>Optimize</strong>
-                <span>Folding, reachability, and dense node ids keep invariants simple.</span>
-              </div>
-              <div class="stage">
-                <strong>Validation plan</strong>
-                <span>Cached per schema identity: predicate kernel + optimized graph.</span>
-              </div>
-            </div>
-            <div class="consumers">
-              <div class="tile">
-                <h3>Plan kernel</h3>
-                <p>Drives <code>is()</code> and the <code>check()</code> verdict preflight without per-node interpreter dispatch.</p>
-                <code>guard.is()</code>
-              </div>
-              <div class="tile">
-                <h3>Optimized graph</h3>
-                <p>Source of truth for runtime-compiled and AOT-emitted predicates, and for introspection.</p>
-                <code>compile() &middot; emitAotModule() &middot; graph()</code>
-              </div>
-              <div class="tile">
-                <h3>Diagnostic collector</h3>
-                <p>Failed <code>check()</code> calls replay the schema-aware collector for issue paths and codes.</p>
-                <code>guard.check()</code>
-              </div>
-            </div>
-            <div class="callout">
-              <span class="icon">&#128274;</span>
-              <p>
-                <strong>Injection-safe codegen:</strong> user-controlled literals, regexps, object
-                keys, keysets, and dynamic schema fallbacks live in side tables referenced by
-                numeric index. Hostile property names cannot escape into generated source &mdash;
-                pinned by dedicated injection-audit tests.
-              </p>
-            </div>
           </section>
 
-          <section id="api" data-doc-section data-title="api builders decoder async messages json schema execution">
-            <p class="eyebrow">API map</p>
-            <h2>Small public surface, strict contracts.</h2>
-            <p class="lede">
-              Every entry point is exported from the package root; builders are also grouped under
-              the <code>t</code> table. The full signatures live in the
-              <a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/api.md"><code>API reference</code></a>.
+          <section id="api" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">API map</span>
+              <span class="i18n-ko" lang="ko">API 지도</span>
             </p>
+            <h2>
+              <span class="i18n-en">Core entry points.</span>
+              <span class="i18n-ko" lang="ko">핵심 진입점.</span>
+            </h2>
             <div class="grid">
               <article class="tile">
                 <h3>Builders</h3>
-                <p>Scalars, literals, arrays, tuples, records, unions, intersections, and lazy recursion.</p>
-                <code>t.strictObject</code>
+                <p><code>t.string</code>, <code>t.number</code>, <code>t.object</code>, <code>t.strictObject</code>, <code>t.union</code>, <code>t.array</code>, <code>t.lazy</code>.</p>
               </article>
               <article class="tile">
-                <h3>Object combinators</h3>
-                <p>Shape-preserving <code>extend</code>, <code>pick</code>, <code>omit</code>, and <code>partial</code>.</p>
-                <code>guard.extend</code>
+                <h3>Validation</h3>
+                <p>
+                  <span class="i18n-en"><code>is()</code> for narrowing, <code>check()</code> for Result diagnostics, <code>assert()</code> for throwing integration boundaries.</span>
+                  <span class="i18n-ko" lang="ko"><code>is()</code>는 타입 좁히기, <code>check()</code>는 Result 기반 진단, <code>assert()</code>는 예외가 필요한 연동 지점에 씁니다.</span>
+                </p>
               </article>
               <article class="tile">
-                <h3>Presence wrappers</h3>
-                <p>Explicit key-absence vs undefined-value vs null-value contracts.</p>
-                <code>t.optional</code>
+                <h3>Generated validators</h3>
+                <p>
+                  <span class="i18n-en"><code>compile()</code>, <code>emitAotModule()</code>, safe mode, unsafe mode, and unchecked mode.</span>
+                  <span class="i18n-ko" lang="ko"><code>compile()</code>, <code>emitAotModule()</code>, safe/unsafe/unchecked 모드.</span>
+                </p>
               </article>
               <article class="tile">
                 <h3>Decoders</h3>
-                <p>Result-returning transform, pipe, and coercion; async variants keep expected failures in <code>Result</code>.</p>
-                <code>t.pipe</code>
+                <p>
+                  <span class="i18n-en"><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.coerce</code>, plus async variants.</span>
+                  <span class="i18n-ko" lang="ko"><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.coerce</code>와 async 변형.</span>
+                </p>
               </article>
               <article class="tile">
-                <h3>Execution</h3>
-                <p>Runtime-compiled validators and standalone AOT module emission from the optimized graph.</p>
-                <code>compile</code>
+                <h3>Messages</h3>
+                <p><code>formatIssue</code>, <code>formatIssues</code>, <code>withMessages</code>, <code>defineMessages</code>.</p>
               </article>
               <article class="tile">
-                <h3>Messages &amp; export</h3>
-                <p>Locale-aware issue formatting (English and Korean built in) and lossless JSON Schema export.</p>
-                <code>toJsonSchema</code>
+                <h3>Export</h3>
+                <p>
+                  <span class="i18n-en"><code>toJsonSchema</code> and <code>schemaToJsonSchema</code> succeed only when semantics are preserved.</span>
+                  <span class="i18n-ko" lang="ko"><code>toJsonSchema</code>와 <code>schemaToJsonSchema</code>는 의미를 보존할 수 있을 때만 성공합니다.</span>
+                </p>
               </article>
             </div>
           </section>
 
-          <section id="adapters" data-doc-section data-title="adapters trpc fastify react hook form resolver">
-            <p class="eyebrow">Ecosystem adapters</p>
-            <h2>Structural adapters without importing frameworks.</h2>
-            <p class="lede">
-              Adapter functions return objects or functions shaped for the target ecosystem.
-              TypeSea does not import tRPC, Fastify, or React Hook Form at runtime.
+          <section id="adapters" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Adapters</span>
+              <span class="i18n-ko" lang="ko">어댑터</span>
             </p>
-            <div class="table-wrap">
-              <table>
-                <thead>
-                  <tr>
-                    <th>Target</th>
-                    <th>Export</th>
-                    <th>Behavior</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  <tr>
-                    <td>tRPC</td>
-                    <td><code>toTrpcParser</code> / <code>toAsyncTrpcParser</code></td>
-                    <td>Parser objects that return decoded values or throw <code>TypeSeaAssertionError</code>.</td>
-                  </tr>
-                  <tr>
-                    <td>Fastify</td>
-                    <td><code>toFastifyRouteSchema</code></td>
-                    <td>Lossless JSON Schema fragments for body, querystring, params, or headers.</td>
-                  </tr>
-                  <tr>
-                    <td>Fastify</td>
-                    <td><code>toFastifyValidatorCompiler</code></td>
-                    <td>Route validators dispatched by <code>httpPart</code>, producing <code>{ value }</code> or <code>{ error }</code>.</td>
-                  </tr>
-                  <tr>
-                    <td>React Hook Form</td>
-                    <td><code>toReactHookFormResolver</code></td>
-                    <td>Async resolver returning a nested field-error tree that RHF traverses by path.</td>
-                  </tr>
-                </tbody>
-              </table>
+            <h2>
+              <span class="i18n-en">Structural adapters without framework dependencies.</span>
+              <span class="i18n-ko" lang="ko">프레임워크 의존성 없이 제공되는 구조적 어댑터.</span>
+            </h2>
+            <div class="grid">
+              <article class="tile">
+                <h3>tRPC</h3>
+                <p><code>toTrpcParser</code> and <code>toAsyncTrpcParser</code>.</p>
+              </article>
+              <article class="tile">
+                <h3>Fastify</h3>
+                <p><code>toFastifyRouteSchema</code> and <code>toFastifyValidatorCompiler</code>.</p>
+              </article>
+              <article class="tile">
+                <h3>React Hook Form</h3>
+                <p><code>toReactHookFormResolver</code>.</p>
+              </article>
             </div>
           </section>
 
-          <section id="benchmarks" data-doc-section data-title="benchmarks performance zod valibot ajv compiled interpreted">
-            <p class="eyebrow">Benchmarks</p>
-            <h2>Measured honestly, gated on every release.</h2>
-            <p class="lede">
-              The suite compares the runtime plan against compiled TypeSea, and both against
-              Zod, Valibot, and Ajv over one JSON-compatible strict-object contract. Comparison
-              packages are development-only measurement tools, and diagnostic-path
-              (<code>check()</code> vs <code>safeParse</code>) rows keep the numbers
-              apples-to-apples.
+          <section id="benchmarks" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Benchmarks</span>
+              <span class="i18n-ko" lang="ko">벤치마크</span>
             </p>
-            <div class="table-wrap">
-              <table>
-                <thead>
-                  <tr>
-                    <th>Valid object path</th>
-                    <th class="num">ops/sec</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  <tr>
-                    <td>TypeSea runtime plan <code>is()</code></td>
-                    <td class="num">496,270</td>
-                  </tr>
-                  <tr>
-                    <td>TypeSea compiled <code>is()</code></td>
-                    <td class="num"><span class="best">4,237,892</span></td>
-                  </tr>
-                  <tr>
-                    <td>Zod <code>safeParse</code></td>
-                    <td class="num">1,363,792</td>
-                  </tr>
-                  <tr>
-                    <td>Valibot <code>safeParse</code></td>
-                    <td class="num">1,384,892</td>
-                  </tr>
-                  <tr>
-                    <td>Ajv compiled</td>
-                    <td class="num">4,312,174</td>
-                  </tr>
-                </tbody>
-              </table>
-            </div>
-            <div class="table-wrap">
-              <table>
-                <thead>
-                  <tr>
-                    <th>Invalid object path</th>
-                    <th class="num">ops/sec</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  <tr>
-                    <td>TypeSea runtime plan <code>is()</code></td>
-                    <td class="num">3,422,416</td>
-                  </tr>
-                  <tr>
-                    <td>TypeSea compiled <code>is()</code></td>
-                    <td class="num"><span class="best">27,125,445</span></td>
-                  </tr>
-                  <tr>
-                    <td>Zod <code>safeParse</code></td>
-                    <td class="num">83,501</td>
-                  </tr>
-                  <tr>
-                    <td>Valibot <code>safeParse</code></td>
-                    <td class="num">902,616</td>
-                  </tr>
-                  <tr>
-                    <td>Ajv compiled</td>
-                    <td class="num">28,953,501</td>
-                  </tr>
-                </tbody>
-              </table>
-            </div>
-            <p class="footnote">
-              Local release smoke, 2026-07-04 KST, single machine &mdash; regression telemetry,
-              not throughput guarantees. The compiled path stays at Ajv-level speed while keeping
-              descriptor-based reads, strict symbol/non-enumerable key rejection, and immutable
-              diagnostics.
+            <h2>
+              <span class="i18n-en">Zod, Valibot, and Ajv comparisons are rendered in the README and engine notes below.</span>
+              <span class="i18n-ko" lang="ko">Zod, Valibot, Ajv와의 비교는 아래 README와 엔진 노트에 포함되어 있습니다.</span>
+            </h2>
+            <p class="lede">
+              <span class="i18n-en">Run <code>npm run bench -- bench/ecosystem.bench.ts --run</code> for the local benchmark suite.</span>
+              <span class="i18n-ko" lang="ko">로컬 벤치마크는 <code>npm run bench -- bench/ecosystem.bench.ts --run</code>으로 실행합니다.</span>
             </p>
-            <div class="code-block">
-              <pre><code>npm run bench -- --run</code></pre>
-            </div>
+            <img class="benchmark-image" src="assets/benchmark-headline.svg" alt="TypeSea benchmark comparison">
           </section>
 
-          <section id="release" data-doc-section data-title="release gate policy typecheck lint test dist api pack consumer provenance">
-            <p class="eyebrow">Release gate</p>
-            <h2>Publishing requires the full local gate.</h2>
-            <p class="lede">
-              One script runs everything CI runs: source policy, docs smoke, typecheck, lint,
-              tests, build, dist policy, public API snapshot, package contents, clean consumer
-              install, benchmark smoke, and pack dry run. CI executes the same gate on
-              Node 20.19, 22, and 24; releases publish with npm provenance.
+          <section id="release" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Release gate</span>
+              <span class="i18n-ko" lang="ko">릴리스 게이트</span>
             </p>
+            <h2>
+              <span class="i18n-en">Use the same gate locally and in CI.</span>
+              <span class="i18n-ko" lang="ko">로컬과 CI에서 같은 gate를 실행합니다.</span>
+            </h2>
             <div class="code-block">
               <pre><code>npm run release:check</code></pre>
             </div>
-            <div class="callout">
-              <span class="icon">&#128737;</span>
-              <p>
-                <strong><code>prepack</code> re-runs the full check</strong>, so even a bare
-                <code>npm publish</code> cannot skip the gate. Package policy rejects any runtime
-                dependency fields before the tarball is accepted.
-              </p>
-            </div>
           </section>
-
-          <section id="files" data-doc-section data-title="reference files api engine notes github">
-            <p class="eyebrow">Reference files</p>
-            <h2>Detailed contracts live in focused documents.</h2>
-            <div class="grid two">
+          <section id="files" data-doc-section>
+            <p class="eyebrow">
+              <span class="i18n-en">Source files</span>
+              <span class="i18n-ko" lang="ko">원본 파일</span>
+            </p>
+            <h2>
+              <span class="i18n-en">The site below renders every maintained documentation source.</span>
+              <span class="i18n-ko" lang="ko">아래에는 현재 유지보수 중인 문서 원본 전체가 그대로 들어 있습니다.</span>
+            </h2>
+            <div class="grid">
               <article class="tile">
-                <h3>API reference</h3>
-                <p>Guard, decoder, AOT, adapter, graph, and JSON Schema behavior with edge semantics.</p>
+                <h3>README.md</h3>
+                <p>
+                  <span class="i18n-en">Project goal, benchmark headline, quick start, API summary, edge semantics, and release workflow.</span>
+                  <span class="i18n-ko" lang="ko">프로젝트 목표, 벤치마크 요약, 빠른 시작, API 개요, 경계 동작, 릴리스 흐름을 다룹니다.</span>
+                </p>
+                <code><a href="https://github.com/Feralthedogg/TypeSea">GitHub README</a></code>
+              </article>
+              <article class="tile">
+                <h3>docs/api.md</h3>
+                <p>
+                  <span class="i18n-en">Guard, builder, decoder, compile, AOT, adapter, graph, JSON Schema, edge, and Result contracts.</span>
+                  <span class="i18n-ko" lang="ko">가드, 빌더, 디코더, 컴파일, AOT, 어댑터, 그래프, JSON Schema, 경계 조건, Result 계약을 정리합니다.</span>
+                </p>
                 <code><a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/api.md">docs/api.md</a></code>
               </article>
               <article class="tile">
-                <h3>Engine notes</h3>
-                <p>V8-facing implementation rules and Sea-of-Nodes validation IR semantics.</p>
+                <h3>docs/engine-notes.md</h3>
+                <p>
+                  <span class="i18n-en">Hot path rules, type-system rules, Sea-of-Nodes validation IR, compiler notes, recursion, and benchmark scope.</span>
+                  <span class="i18n-ko" lang="ko">핫패스 규칙, 타입 시스템 규칙, Sea-of-Nodes 검증 IR, 컴파일러 설계, 재귀 처리, 벤치마크 범위를 설명합니다.</span>
+                </p>
                 <code><a href="https://github.com/Feralthedogg/TypeSea/blob/main/docs/engine-notes.md">docs/engine-notes.md</a></code>
               </article>
             </div>
           </section>
+<article id="readme" class="source-doc doc-content" data-doc-section>
+            <header>
+              <p class="eyebrow">
+                <span class="i18n-en">README</span>
+                <span class="i18n-ko" lang="ko">README</span>
+              </p>
+              <h2>
+                <span class="i18n-en">README</span>
+                <span class="i18n-ko" lang="ko">README</span>
+              </h2>
+              <p>
+                <span class="i18n-en">Rendered from <code>README.md</code>.</span>
+                <span class="i18n-ko" lang="ko"><code>docs/ko/readme.md</code>에서 렌더링했습니다.</span>
+              </p>
+            </header>
+            <div class="locale-en">
+<h2 id="readme-en-typesea">TypeSea</h2>
+<p><a href="https://github.com/Feralthedogg/TypeSea/actions/workflows/ci.yml/badge.svg">![CI</a>](https://github.com/Feralthedogg/TypeSea/actions/workflows/ci.yml) <span class="muted-link">![Socket Badge</span>](https://badge.socket.dev/npm/package/typesea/0.3.0) <span class="muted-link">![License</span>](./LICENSE) <span class="muted-link">TypeScript</span> <span class="muted-link">Dependencies</span> <span class="muted-link">Tree-shakeable</span> <span class="muted-link">Side-effect free</span> <span class="muted-link">No dependencies</span> <span class="muted-link">Module</span> <span class="muted-link">Node</span></p>
+<p><strong>TypeSea</strong> is a <strong>zero-runtime-dependency TypeScript runtime narrowing library</strong> built around <strong>immutable guards</strong>, optimized <strong>Sea-of-Nodes validation plans</strong>, runtime compilation, and AOT source generation.</p>
+<h3 id="readme-en-benchmark-headline">Benchmark Headline</h3>
+<p>Last local benchmark on 2026-07-04 KST: <code>npm run bench -- bench/ecosystem.bench.ts --run</code>, strict-object contract, operations per second on one machine.</p>
+<p><img class="benchmark-image" src="assets/benchmark-headline.svg" alt="TypeSea benchmark comparison"></p>
+<p>TypeSea safe compiled validators are already in Ajv's boolean hot-path class while keeping descriptor-based hostile-input semantics. Unsafe and unchecked FastMode are the bragging-rights path for trusted normalized data: direct field loads, allocation-light strict-key loops, and V8-friendly monomorphic codegen.</p>
+<blockquote><p>Goal: not &quot;probably valid&quot;, but <strong>provably parity-tested validation</strong> that never executes user code, never throws on expected failures, and never leaks mutable state across a public boundary.</p></blockquote>
+<aside class="admonition important"><strong class="admonition-title">IMPORTANT</strong><p>TypeSea is designed for <strong>hostile boundary data</strong>: property reads go through descriptors so <strong>user getters never execute</strong>, <code>__proto__</code>/<code>constructor</code> keys are handled with null-prototype lookups, user regexes are cloned and <code>lastIndex</code>-reset, and cyclic inputs validate finitely. Expected failures return frozen <code>Result</code> values — <code>any</code>, <code>try</code>, and <code>catch</code> are banned from the entire codebase and enforced by policy gates.</p></aside>
+<hr>
+<h3 id="readme-en-why">Why</h3>
+<p>Many validation libraries fall short when you care about:</p>
+<ul><li><strong>untrusted input that fights back</strong> (getters with side effects, prototype</li></ul>
+<p>pollution keys, forged schema objects, revoked proxies)</p>
+<ul><li><strong>identical verdicts across execution strategies</strong> (runtime plan vs compiled</li></ul>
+<p>vs AOT-generated validators)</p>
+<ul><li><strong>diagnostics without exceptions</strong> (<code>Result</code> values instead of <code>throw</code>)</li><li><strong>immutability at every public boundary</strong></li></ul>
+<p>TypeSea focuses on:</p>
+<ul><li><strong>no user-code execution during validation</strong></li><li><strong>runtime plan / compiled / AOT parity, enforced by a seeded generative fuzzer</strong></li><li><strong>injection-safe code generation</strong> (side tables, never string interpolation)</li><li><strong>explicit presence semantics</strong> (<code>optional</code> vs <code>undefinedable</code>)</li></ul>
+<hr>
+<h3 id="readme-en-key-properties">Key Properties</h3>
+<ul><li><strong>Zero dependencies</strong>: no runtime, peer, optional, or bundled dependencies —</li></ul>
+<p>mechanically enforced by package policy before every release.</p>
+<ul><li><strong>Three engines, one semantics</strong>: <code>is()</code>/<code>check()</code> execute a cached validation</li></ul>
+<p>plan, <code>compile()</code> emits runtime predicates from optimized IR, and <code>emitAotModule()</code> emits standalone validator source. The runtime plan owns both the graph and a schema-specialized kernel, so the graph is the source of truth for generated validators without forcing ordinary <code>is()</code> through a per-node interpreter. Parity is fuzz-tested with sparse arrays, accessor properties, symbol keys, and non-enumerable extras included.</p>
+<ul><li><strong>Frozen public surface</strong>: guards, schemas, graphs, diagnostics, and JSON</li></ul>
+<p>Schema payloads are frozen before they cross an API boundary.</p>
+<ul><li><strong>Lossless-only export</strong>: JSON Schema and AOT export succeed only when no</li></ul>
+<p>semantics would be lost; runtime-only contracts return typed issues instead of silently weakening the schema.</p>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>TypeSea is <strong>ESM-only</strong>: the package ships <code>&quot;type&quot;: &quot;module&quot;</code> with no CommonJS build. Node.js <code>&gt;= 20.19</code> can also load it via <code>require(esm)</code> through the <code>default</code> export condition.</p></aside>
+<hr>
+<h3 id="readme-en-quick-start">Quick Start</h3>
+<pre><code>import { compile, t, toJsonSchema, type Infer } from &quot;typesea&quot;;
+
+const User = t.strictObject({
+  id: t.string.uuid(),
+  email: t.string.email(),
+  age: t.number.int().nonnegative(),
+  role: t.enum([&quot;admin&quot;, &quot;user&quot;]),
+  tags: t.array(t.string.min(1)).max(8)
+});
+
+type User = Infer&lt;typeof User&gt;;
+
+// 1) Boolean narrowing — avoids diagnostic allocation on success
+if (User.is(input)) {
+  input.id; // narrowed
+}
+
+// 2) Immutable diagnostics — frozen Result, never throws on expected failure
+const checked = User.check(input);
+if (!checked.ok) {
+  console.log(checked.error); // frozen issue list with paths
+}
+
+// 3) Hot path — generated validator code
+const FastUser = compile(User, { name: &quot;isUser&quot; });
+
+// 4) Interop — lossless-only JSON Schema export
+const schema = toJsonSchema(User);</code></pre>
+<p>Use <code>is()</code> for the allocation-light boolean path. Use <code>check()</code> when callers need the full immutable diagnostic list, or <code>checkFirst()</code> when a hot rejection path only needs one machine-readable issue. Use <code>compile()</code> or <code>emitAotModule()</code> when a stable schema is hot enough to deserve generated validator code. Compiled and AOT <code>checkFirst()</code> use a dedicated first-fault collector instead of building the full issue list and slicing it afterward.</p>
+<aside class="admonition caution"><strong class="admonition-title">CAUTION</strong><p><code>compile()</code> builds the validator with <code>new Function</code>, which throws under a Content-Security-Policy that forbids <code>unsafe-eval</code>. In CSP-restricted environments, generate validator source ahead of time with <code>emitAotModule()</code> instead.</p></aside>
+<h4 id="readme-en-unsafe-fastmode">Unsafe FastMode</h4>
+<pre><code>const FastButLooseUser = compile(User, {
+  name: &quot;isUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});
+
+const FastTrustedShapeUser = compile(User, {
+  name: &quot;isUserTrustedShape&quot;,
+  mode: &quot;unchecked&quot;
+});</code></pre>
+<p><code>compile(..., { mode: &quot;unsafe&quot; })</code> and <code>emitAotModule(..., { mode: &quot;unsafe&quot; })</code> emit the V8-friendliest predicate TypeSea can generate: required object fields are read with direct bracket access, arrays and tuples use direct indexed loads, discriminants avoid descriptor reads, and strict-object extras are checked with an allocation-free <code>for...in</code> loop. This mode is for trusted, already-normalized data on extremely hot paths.</p>
+<p>The default is still <code>mode: &quot;safe&quot;</code>. Unsafe mode may execute getters, may accept prototype-backed values, and strict objects do not reject symbol or non-enumerable extras. Use it only when the caller owns the object graph or has already normalized input into plain data records. Unsafe generated predicates may also embed escaped static property keys directly in source so V8 can use ordinary property-load inline caches.</p>
+<p><code>mode: &quot;unchecked&quot;</code> goes one step further: it trusts the object shape and skips strict extra-key loops entirely. That is the fastest path for already-owned DTOs, but strict objects no longer reject any extra keys.</p>
+<p>In unsafe and unchecked modes, successful compiled <code>check()</code> calls return a raw <code>{ ok: true, value }</code> object instead of freezing the success result. Failed diagnostics are still frozen. Safe mode keeps the fully frozen Result contract. FastMode diagnostic collectors also use the same trusted direct-read object shape where possible, so their issue codes can be less hostile-input-specific than safe mode for missing/accessor-backed fields and sparse/accessor-backed array or record slots. Discriminant diagnostics also read tags directly.</p>
+<hr>
+<h3 id="readme-en-presence-semantics">Presence Semantics</h3>
+<p>Object presence is explicit — two different wrappers express two different contracts:</p>
+<div class="table-wrap"><table><thead><tr><th>Wrapper</th><th>Key may be absent</th><th>Value may be <code>undefined</code></th><th>Inferred type</th></tr></thead><tbody><tr><td><code>t.optional(inner)</code></td><td>yes</td><td>no</td><td><code>key?: T</code></td></tr>
+<tr><td><code>t.undefinedable(inner)</code></td><td>no</td><td>yes</td><td><code>key: T | undefined</code></td></tr>
+<tr><td><code>t.nullable(inner)</code></td><td>—</td><td>value may be <code>null</code></td><td><code>key: T | null</code></td></tr></tbody></table></div>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>Presence survives wrapper composition: <code>t.nullable(t.optional(x))</code> still means &quot;the key may be absent&quot; — inference and runtime agree on this under <code>exactOptionalPropertyTypes</code>.</p></aside>
+<hr>
+<h3 id="readme-en-execution-model">Execution Model</h3>
+<p>TypeSea keeps the public schema tree for builder validation and diagnostics, then lowers each schema identity into a cached validation plan. The plan owns an optimized Sea-of-Nodes graph and a schema-specialized predicate kernel. <code>Guard.is()</code> uses the kernel to avoid per-node interpreter dispatch, while <code>compile()</code> and <code>emitAotModule()</code> emit predicates from the optimized graph. <code>check()</code> first asks the same plan for the verdict; failed values then replay the schema-aware diagnostic collector to produce issue paths and codes.</p>
+<pre><code>builder -&gt; frozen schema -&gt; lower -&gt; Sea-of-Nodes IR -&gt; optimize
+optimize -&gt; ValidationPlan { graph, schema kernel }
+schema kernel -&gt; Guard.is() / check() preflight
+graph -&gt; compile() predicate / emitAotModule() predicate / Guard.graph()
+failed check() -&gt; schema-aware diagnostic collector</code></pre>
+<aside class="admonition important"><strong class="admonition-title">IMPORTANT</strong><p>Generated validators keep <strong>user-controlled values out of source text</strong>: literals, regexps, object keys, keysets, and dynamic schema fallbacks live in <strong>side tables</strong> referenced by numeric index. Hostile property names cannot escape into generated code — this is pinned by dedicated injection-audit tests.</p></aside>
+<hr>
+<h3 id="readme-en-performance-snapshot">Performance Snapshot</h3>
+<p>Last local benchmark on 2026-07-04 KST, using <code>npm run bench -- bench/ecosystem.bench.ts --run</code> on the benchmark strict-object contract. These are operations per second on one machine, not release guarantees.</p>
+<div class="table-wrap"><table><thead><tr><th>Valid object path</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>is()</code></td><td>513,701</td></tr>
+<tr><td>TypeSea compiled safe <code>is()</code></td><td>4,297,306</td></tr>
+<tr><td>TypeSea compiled unsafe <code>is()</code></td><td>36,297,653</td></tr>
+<tr><td>TypeSea compiled unchecked <code>is()</code></td><td>42,581,174</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>1,343,756</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>1,406,528</td></tr>
+<tr><td>Ajv compiled</td><td>4,275,389</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>Valid diagnostic path</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>check()</code></td><td>503,232</td></tr>
+<tr><td>TypeSea compiled safe <code>check()</code></td><td>3,903,929</td></tr>
+<tr><td>TypeSea compiled unsafe <code>check()</code></td><td>35,568,425</td></tr>
+<tr><td>TypeSea compiled unchecked <code>check()</code></td><td>40,084,605</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>1,355,014</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>1,378,266</td></tr>
+<tr><td>Ajv compiled</td><td>4,278,587</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>Invalid object path</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>is()</code></td><td>3,636,369</td></tr>
+<tr><td>TypeSea compiled safe <code>is()</code></td><td>42,080,241</td></tr>
+<tr><td>TypeSea compiled unsafe <code>is()</code></td><td>49,654,076</td></tr>
+<tr><td>TypeSea compiled unchecked <code>is()</code></td><td>50,482,732</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>84,272</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>878,521</td></tr>
+<tr><td>Ajv compiled</td><td>27,820,643</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>Invalid diagnostic path</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>check()</code></td><td>420,446</td></tr>
+<tr><td>TypeSea compiled safe <code>check()</code></td><td>2,086,129</td></tr>
+<tr><td>TypeSea compiled unsafe <code>check()</code></td><td>3,077,367</td></tr>
+<tr><td>TypeSea compiled unchecked <code>check()</code></td><td>3,673,508</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>79,613</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>887,991</td></tr>
+<tr><td>Ajv compiled</td><td>28,713,035</td></tr></tbody></table></div>
+<p>The safe compiled path stays close to Ajv while retaining TypeSea hostile-input semantics: descriptor-based property reads, symbol/non-enumerable strict-key rejection, presence semantics, immutable diagnostics, and TypeScript guard inference. Unsafe and unchecked compiled modes are faster because they deliberately give up parts of that hostile-input contract.</p>
+<hr>
+<h3 id="readme-en-api-reference">API Reference</h3>
+<p>All public entry points are exported from the package root; builders are also grouped under the <code>t</code> table.</p>
+<h4 id="readme-en-builders">Builders</h4>
+<div class="table-wrap"><table><thead><tr><th>Area</th><th>Entry points</th></tr></thead><tbody><tr><td>Scalar guards</td><td><code>t.unknown</code>, <code>t.never</code>, <code>t.string</code>, <code>t.number</code>, <code>t.date</code>, <code>t.bigint</code>, <code>t.symbol</code>, <code>t.boolean</code>, <code>t.null</code>, <code>t.undefined</code>, <code>t.void</code></td></tr>
+<tr><td>String checks</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code>, <code>.regex</code>, <code>.startsWith</code>, <code>.endsWith</code>, <code>.includes</code>, <code>.uuid</code>, <code>.email</code>, <code>.url</code>, <code>.isoDate</code>, <code>.isoDateTime</code>, <code>.ulid</code>, <code>.ipv4</code>, <code>.ipv6</code></td></tr>
+<tr><td>Number checks</td><td><code>.int</code>, <code>.finite</code>, <code>.safe</code>, <code>.gte</code>, <code>.lte</code>, <code>.min</code>, <code>.max</code>, <code>.gt</code>, <code>.lt</code>, <code>.multipleOf</code>, <code>.positive</code>, <code>.nonnegative</code>, <code>.negative</code>, <code>.nonpositive</code></td></tr>
+<tr><td>Date checks</td><td><code>.min</code>, <code>.max</code></td></tr>
+<tr><td>Literal and containers</td><td><code>t.literal</code>, <code>t.enum</code>, <code>t.array</code>, <code>t.tuple</code>, tuple rest, <code>t.record</code>, <code>t.map</code>, <code>t.set</code>, <code>t.json</code></td></tr>
+<tr><td>Array checks</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code></td></tr>
+<tr><td>Objects</td><td><code>t.object</code>, <code>t.strictObject</code>, <code>extend</code>, <code>safeExtend</code>, <code>merge</code>, <code>pick</code>, <code>omit</code>, <code>partial</code>, <code>deepPartial</code>, <code>required</code>, <code>strict</code>, <code>passthrough</code>, <code>strip</code>, <code>catchall</code></td></tr>
+<tr><td>Runtime object contracts</td><td><code>t.instanceOf</code>, <code>t.property</code>, <code>guard.property</code></td></tr>
+<tr><td>Composition</td><td><code>t.union</code>, <code>t.discriminatedUnion</code>, <code>t.intersect</code>, <code>guard.intersect</code></td></tr>
+<tr><td>Presence wrappers</td><td><code>t.optional</code>, <code>t.undefinedable</code>, <code>t.nullable</code>, <code>t.nullish</code></td></tr>
+<tr><td>Dynamic contracts</td><td><code>t.lazy</code>, <code>t.refine</code></td></tr></tbody></table></div>
+<h4 id="readme-en-decoders">Decoders</h4>
+<div class="table-wrap"><table><thead><tr><th>Area</th><th>Entry points</th></tr></thead><tbody><tr><td>Sync decoders</td><td><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.default</code>, <code>t.defaultValue</code>, <code>t.prefault</code>, <code>t.catch</code>, <code>t.codec</code>, <code>t.coerce</code>, <code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, <code>t.string.toUpperCase()</code></td></tr>
+<tr><td>Async decoders</td><td><code>t.asyncDecoder</code>, <code>t.asyncRefine</code>, <code>t.asyncTransform</code>, <code>t.asyncPipe</code></td></tr></tbody></table></div>
+<h4 id="readme-en-execution-export">Execution &amp; Export</h4>
+<div class="table-wrap"><table><thead><tr><th>Area</th><th>Entry points</th></tr></thead><tbody><tr><td>Guard methods</td><td><code>guard.is()</code>, <code>guard.check()</code>, <code>guard.checkFirst()</code>, <code>guard.graph()</code></td></tr>
+<tr><td>Generated validators</td><td><code>compile</code>, <code>emitAotModule</code></td></tr>
+<tr><td>JSON Schema</td><td><code>toJsonSchema</code></td></tr>
+<tr><td>Messages</td><td><code>formatIssue</code>, <code>formatIssues</code>, <code>flattenIssues</code>, <code>withMessages</code></td></tr></tbody></table></div>
+<h4 id="readme-en-messages-adapters">Messages &amp; Adapters</h4>
+<div class="table-wrap"><table><thead><tr><th>Area</th><th>Entry points</th></tr></thead><tbody><tr><td>Messages / i18n</td><td><code>formatIssue</code>, <code>formatIssues</code>, <code>flattenIssues</code>, <code>withMessages</code>, <code>defineMessages</code></td></tr>
+<tr><td>tRPC</td><td><code>toTrpcParser</code>, <code>toAsyncTrpcParser</code></td></tr>
+<tr><td>Fastify</td><td><code>toFastifyRouteSchema</code>, <code>toFastifyValidatorCompiler</code></td></tr>
+<tr><td>React Hook Form</td><td><code>toReactHookFormResolver</code></td></tr></tbody></table></div>
+<p>Adapters accept compiled guards too. Compile once at startup, then pass the compiled guard into parser or validator-compiler adapters so framework hot paths reuse the generated predicate.</p>
+<pre><code>const FastUser = compile(User);
+const trpcParser = toTrpcParser(FastUser);
+const fastifyCompiler = toFastifyValidatorCompiler(FastUser);
+
+// Trusted normalized data only: trades hostile-input hardening for direct reads.
+const UnsafeUser = compile(User, { mode: &quot;unsafe&quot; });
+const internalParser = toTrpcParser(UnsafeUser);</code></pre>
+<aside class="admonition tip"><strong class="admonition-title">TIP</strong><p>Match the inference alias to the source kind: <code>Infer&lt;&gt;</code> for guards, <code>InferDecoder&lt;&gt;</code> for decoders, <code>InferAsyncDecoder&lt;&gt;</code> for async decoders. Applying <code>Infer&lt;&gt;</code> to a decoder resolves to <code>never</code> — if a downstream type suddenly collapses, this is the first thing to check.</p></aside>
+<hr>
+<h3 id="readme-en-edge-semantics">Edge Semantics</h3>
+<p>Deliberate, documented, and pinned by tests:</p>
+<div class="table-wrap"><table><thead><tr><th>Input</th><th>Behavior</th></tr></thead><tbody><tr><td><code>NaN</code>, <code>Infinity</code></td><td>rejected by <code>t.number</code> (finite numbers only); <code>t.literal(NaN)</code> matches <code>NaN</code></td></tr>
+<tr><td><code>-0</code> vs <code>0</code></td><td>literals match via <code>Object.is</code>; diagnostics format <code>-0</code> distinctly</td></tr>
+<tr><td>Getter-backed properties</td><td>never executed; treated as missing/invalid data</td></tr>
+<tr><td><code>__proto__</code>, <code>constructor</code> keys</td><td>validated as plain own keys, no pollution</td></tr>
+<tr><td>Sparse array holes</td><td>read as <code>undefined</code> without executing accessors</td></tr>
+<tr><td>Strict object extras</td><td>rejected via <code>Reflect.ownKeys</code> — including symbol keys and non-enumerable properties</td></tr>
+<tr><td><code>catchall</code> extras</td><td>unknown own keys are descriptor-read and validated by the catchall schema</td></tr>
+<tr><td><code>strip()</code></td><td>validation-only alias for accepting extras; TypeSea does not clone stripped output</td></tr>
+<tr><td><code>t.date</code></td><td>accepts valid JavaScript <code>Date</code> objects; <code>.min</code> and <code>.max</code> compare epoch milliseconds without reading user-overridable Date methods</td></tr>
+<tr><td><code>t.map</code>, <code>t.set</code>, <code>t.instanceOf</code></td><td>runtime-only contracts; JSON Schema and AOT export reject them instead of weakening semantics</td></tr>
+<tr><td><code>property</code></td><td>validates own data properties only; getter-backed properties are rejected</td></tr>
+<tr><td>Global-flag regexes</td><td>cloned at construction; <code>lastIndex</code> reset before every test</td></tr>
+<tr><td>UUID</td><td>accepts RFC 9562 versions 1–8 plus the nil UUID</td></tr>
+<tr><td>Cyclic input values</td><td>validate finitely via (value × schema) active-pair tracking</td></tr>
+<tr><td>Nesting depth</td><td>capped at 256 recursive frames; deeper input fails instead of overflowing the stack</td></tr></tbody></table></div>
+<hr>
+<h3 id="readme-en-best-practices-pitfalls">Best Practices &amp; Pitfalls</h3>
+<aside class="admonition warning"><strong class="admonition-title">WARNING</strong><p><strong>Recursive guards need an explicit type annotation.</strong> TypeScript cannot infer a self-referential initializer (TS7022):</p>
+<pre><code>interface ListNode {
+  readonly value: string;
+  readonly next?: ListNode;
+}
+
+const Node: Guard&lt;ListNode&gt; = t.lazy((): Guard&lt;ListNode&gt; =&gt;
+  t.object({ value: t.string, next: t.optional(Node) })
+);</code></pre></aside>
+<ul><li>**Boundary data enters as <code>unknown</code>.** Do not pre-narrow with <code>as</code> — the</li></ul>
+<p>builder API is typed so that narrowing happens through validation.</p>
+<ul><li>**Recursive contracts go through <code>t.lazy</code>.** Direct schema object cycles are</li></ul>
+<p>rejected at construction.</p>
+<ul><li><strong>Choose the engine by schema lifetime.</strong> One-off schemas: runtime plan.</li></ul>
+<p>Stable hot schemas: <code>compile()</code>. CSP environments or build-time generation: <code>emitAotModule()</code>.</p>
+<ul><li><strong>Decoders do not embed in object shapes.</strong> Compose transformations with</li></ul>
+<p><code>t.pipe</code> around a validated shape instead of mixing decoders into <code>t.object</code> entries.</p>
+<hr>
+<h3 id="readme-en-verification">Verification</h3>
+<p>Every gate that CI runs is a local npm script:</p>
+<pre><code>npm run check           # policy, docs, typecheck, lint, tests, build, dist, API snapshot, pack
+npm run check:consumer  # tarball install + runtime/type smoke in a temp project
+npm run bench -- --run  # benchmark smoke
+npm run pack:dry        # package contents dry run
+npm run release:check   # the full pre-publish gate (everything above)</code></pre>
+<p><code>npm run release:check</code> runs the same gate expected before publishing: typecheck, lint, tests, build, docs smoke, dist policy, public API snapshot, package contents, consumer install, benchmark smoke, and pack dry run. CI executes it on Node 20.19, 22, and 24; releases publish with npm provenance.</p>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>Benchmark comparison packages (Zod, Valibot, Ajv) are dev dependencies only — package policy rejects them from every runtime dependency field. The benchmark suite reports both boolean-path and diagnostic-path (<code>check()</code> vs <code>safeParse</code>) comparisons, so numbers stay apples-to-apples.</p></aside>
+<hr>
+<h3 id="readme-en-documentation">Documentation</h3>
+<ul><li><a href="#overview">Documentation site</a></li><li><a href="#api-reference">API reference</a></li><li><a href="#engine-notes">Engine notes</a></li></ul>
+<hr>
+<h3 id="readme-en-license">License</h3>
+<p>MIT License. See <a href="https://github.com/Feralthedogg/TypeSea/blob/main/LICENSE">LICENSE</a>.</p>
+            </div>
+            <div class="locale-ko" lang="ko">
+<h2 id="readme-ko-typesea">TypeSea</h2>
+<p><strong>TypeSea</strong>는 런타임 의존성 없이 TypeScript 값을 검증하고 타입을 좁히는 라이브러리입니다. 불변 스키마, Sea-of-Nodes에서 영향을 받은 검증 IR, 런타임 컴파일, AOT 소스 생성을 한 흐름으로 묶는 것을 목표로 합니다.</p>
+<h3 id="readme-ko-벤치마크-요약">벤치마크 요약</h3>
+<p>마지막 로컬 벤치마크는 2026-07-04 KST에 실행했습니다. 명령은 <code>npm run bench -- bench/ecosystem.bench.ts --run</code>이며, strict object 계약을 대상으로 한 단일 머신의 초당 실행 횟수입니다. 아래 수치는 회귀를 잡기 위한 로컬 측정값이지, 릴리스 성능 보증값은 아닙니다.</p>
+<p><img class="benchmark-image" src="assets/benchmark-headline.svg" alt="TypeSea benchmark comparison"></p>
+<p>TypeSea의 안전 모드 컴파일 검증기는 getter 실행 방지와 strict extra key 검사 같은 적대적 입력 방어를 유지하면서도 Ajv의 boolean hot path에 가까운 성능을 냅니다. <code>unsafe</code>와 <code>unchecked</code> FastMode는 호출자가 이미 입력을 정규화했고 객체 그래프를 신뢰할 수 있을 때 쓰는 성능 우선 경로입니다. 이 모드에서는 직접 필드 로드, 할당을 줄인 strict-key loop, V8이 inline cache를 붙이기 쉬운 코드 형태를 사용합니다.</p>
+<blockquote><p>목표는 &quot;대충 유효해 보이면 통과&quot;가 아닙니다. TypeSea의 목표는 <strong>런타임 실행, 컴파일 실행, AOT 실행이 같은 판정을 내린다는 사실을 테스트로 고정하는 검증기</strong>입니다. 사용자 코드를 실행하지 않고, 예상 가능한 실패에서 예외를 던지지 않으며, 공개 API 경계 밖으로 변경 가능한 내부 상태를 내보내지 않는 것을 기본 원칙으로 둡니다.</p></blockquote>
+<aside class="admonition important"><strong class="admonition-title">IMPORTANT</strong><p>TypeSea는 <strong>적대적인 경계 입력</strong>을 전제로 설계했습니다. 속성 읽기는 descriptor를 통하므로 <strong>사용자 getter를 실행하지 않습니다</strong>. <code>__proto__</code>와 <code>constructor</code> key는 null-prototype lookup으로 처리하고, 사용자 regexp는 복제한 뒤 <code>lastIndex</code>를 reset하며, 순환 입력도 유한하게 검증합니다. 예상 가능한 실패는 동결된 <code>Result</code>로 반환합니다. 불명확한 타입 탈출과 암묵적 예외 흐름에 기대지 않도록 코드베이스 전체에 정책 게이트를 둡니다.</p></aside>
+<hr>
+<h3 id="readme-ko-왜-만들었나">왜 만들었나</h3>
+<p>검증 라이브러리를 실제 경계 입력에 쓰다 보면 다음 조건을 동시에 만족시키기 어렵습니다.</p>
+<ul><li>getter 부작용, prototype pollution key, 위조된 schema object, revoked proxy처럼 검증 자체에 저항하는 입력</li><li>런타임 계획, 컴파일된 검증기, AOT로 생성한 검증기 사이의 동일한 판정</li><li><code>throw</code> 대신 <code>Result</code>로 표현되는 명시적 실패</li><li>공개 API 경계를 지날 때마다 유지되는 불변성</li></ul>
+<p>TypeSea는 아래 원칙에 집중합니다.</p>
+<ul><li>검증 중 사용자 코드 실행 금지</li><li>런타임, 컴파일, AOT 실행 경로의 판정 일치를 seeded fuzzer로 검증</li><li>코드 생성 시 사용자 입력을 소스 문자열에 직접 삽입하지 않기</li><li><code>optional</code>과 <code>undefinedable</code>을 분리하는 명시적 key presence 규칙</li></ul>
+<hr>
+<h3 id="readme-ko-핵심-속성">핵심 속성</h3>
+<ul><li><strong>런타임 의존성 없음</strong>: runtime, peer, optional, bundled dependency가 없습니다. 릴리스 전에 package policy가 이를 기계적으로 검증합니다.</li><li><strong>세 실행 경로, 하나의 의미</strong>: <code>is()</code>와 <code>check()</code>는 cached validation plan을 실행하고, <code>compile()</code>은 최적화된 IR에서 런타임 predicate를 생성하며, <code>emitAotModule()</code>은 standalone validator source를 만듭니다. 일반 <code>is()</code>는 per-node interpreter를 타지 않고 schema-specialized kernel을 사용합니다. sparse array, accessor property, symbol key, non-enumerable extra까지 포함해 parity fuzz test를 돌립니다.</li><li><strong>동결된 공개 표면</strong>: guard, schema, graph, diagnostic, JSON Schema payload는 공개 API 경계를 넘기 전에 freeze됩니다.</li><li><strong>손실 없는 export만 허용</strong>: JSON Schema와 AOT export는 TypeSea 계약을 의미 손실 없이 표현할 수 있을 때만 성공합니다. 런타임 전용 계약은 schema를 약화시키지 않고 typed issue를 반환합니다.</li></ul>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>TypeSea는 <strong>ESM-only</strong> 패키지입니다. <code>&quot;type&quot;: &quot;module&quot;</code>만 제공하며 CommonJS build는 없습니다. Node.js <code>&gt;= 20.19</code>에서는 <code>default</code> export condition을 통해 <code>require(esm)</code> 로드도 가능합니다.</p></aside>
+<hr>
+<h3 id="readme-ko-빠른-시작">빠른 시작</h3>
+<pre><code>import { compile, t, toJsonSchema, type Infer } from &quot;typesea&quot;;
+
+const User = t.strictObject({
+  id: t.string.uuid(),
+  email: t.string.email(),
+  age: t.number.int().nonnegative(),
+  role: t.enum([&quot;admin&quot;, &quot;user&quot;]),
+  tags: t.array(t.string.min(1)).max(8)
+});
+
+type User = Infer&lt;typeof User&gt;;
+
+// 1) Boolean narrowing: 성공 경로에서 진단 객체를 만들지 않습니다.
+if (User.is(input)) {
+  input.id; // narrowed
+}
+
+// 2) Immutable diagnostics: 예상 가능한 실패는 Result로 받습니다.
+const checked = User.check(input);
+if (!checked.ok) {
+  console.log(checked.error); // path가 포함된 동결 issue 목록
+}
+
+// 3) Hot path: 검증 코드를 생성합니다.
+const FastUser = compile(User, { name: &quot;isUser&quot; });
+
+// 4) Interop: 의미 손실이 없을 때만 JSON Schema로 내보냅니다.
+const schema = toJsonSchema(User);</code></pre>
+<p><code>is()</code>는 할당이 적은 boolean 경로에 씁니다. 호출자가 전체 실패 이유와 path를 필요로 하면 <code>check()</code>를 씁니다. hot rejection path에서 기계가 읽을 첫 번째 실패만 필요하면 <code>checkFirst()</code>를 씁니다. 스키마가 안정적이고 호출 빈도가 높다면 <code>compile()</code> 또는 <code>emitAotModule()</code>을 씁니다. compiled/AOT <code>checkFirst()</code>는 전체 issue list를 만든 뒤 자르지 않고 전용 first-fault collector를 사용합니다.</p>
+<aside class="admonition caution"><strong class="admonition-title">CAUTION</strong><p><code>compile()</code>은 <code>new Function</code>으로 검증기를 생성합니다. <code>unsafe-eval</code>을 금지하는 Content-Security-Policy 환경에서는 사용할 수 없습니다. CSP 제한 환경에서는 <code>emitAotModule()</code>로 빌드 시점에 validator source를 생성하세요.</p></aside>
+<h4 id="readme-ko-unsafe-fastmode">Unsafe FastMode</h4>
+<pre><code>const FastButLooseUser = compile(User, {
+  name: &quot;isUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});
+
+const FastTrustedShapeUser = compile(User, {
+  name: &quot;isUserTrustedShape&quot;,
+  mode: &quot;unchecked&quot;
+});</code></pre>
+<p><code>compile(..., { mode: &quot;unsafe&quot; })</code>와 <code>emitAotModule(..., { mode: &quot;unsafe&quot; })</code>는 TypeSea가 생성할 수 있는 가장 V8 친화적인 predicate를 방출합니다. required object field는 direct bracket access로 읽고, array와 tuple은 direct indexed load를 쓰며, discriminant는 descriptor read를 피합니다. strict-object extra는 allocation-free <code>for...in</code> loop로 검사합니다.</p>
+<p>기본값은 여전히 <code>mode: &quot;safe&quot;</code>입니다. unsafe mode는 getter를 실행할 수 있고, prototype-backed value를 받아들일 수 있으며, strict object에서 symbol 또는 non-enumerable extra를 거부하지 않습니다. 호출자가 객체 그래프를 소유하고 있거나 입력을 plain data record로 이미 정규화한 경우에만 사용하세요.</p>
+<p><code>mode: &quot;unchecked&quot;</code>는 한 단계 더 나아가 object shape을 신뢰하고 strict extra-key loop 자체를 건너뜁니다. 이미 소유한 DTO에서는 가장 빠른 경로지만, strict object가 더 이상 extra key를 거부하지 않습니다.</p>
+<p>unsafe와 unchecked mode에서 successful compiled <code>check()</code>는 frozen success result 대신 raw <code>{ ok: true, value }</code> object를 반환합니다. 실패 진단은 계속 freeze됩니다. safe mode는 success와 failure 모두 frozen <code>Result</code> 계약을 유지합니다.</p>
+<hr>
+<h3 id="readme-ko-key-presence">Key Presence</h3>
+<p>객체 key 존재 여부는 명시적으로 표현합니다. 서로 다른 wrapper는 서로 다른 계약을 뜻합니다.</p>
+<div class="table-wrap"><table><thead><tr><th>Wrapper</th><th>key 생략 허용</th><th>value <code>undefined</code> 허용</th><th>추론 타입</th></tr></thead><tbody><tr><td><code>t.optional(inner)</code></td><td>yes</td><td>no</td><td><code>key?: T</code></td></tr>
+<tr><td><code>t.undefinedable(inner)</code></td><td>no</td><td>yes</td><td><code>key: T | undefined</code></td></tr>
+<tr><td><code>t.nullable(inner)</code></td><td>-</td><td>value may be <code>null</code></td><td><code>key: T | null</code></td></tr></tbody></table></div>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>presence는 wrapper composition을 지나도 유지됩니다. <code>t.nullable(t.optional(x))</code>는 여전히 &quot;key가 없어도 된다&quot;는 뜻입니다. <code>exactOptionalPropertyTypes</code> 아래에서 타입 추론과 런타임 동작은 같은 의미를 가집니다.</p></aside>
+<hr>
+<h3 id="readme-ko-실행-모델">실행 모델</h3>
+<p>TypeSea는 builder validation과 diagnostic을 위해 public schema tree를 유지합니다. 그 뒤 각 schema identity를 cached validation plan으로 낮춥니다. plan은 최적화된 Sea-of-Nodes graph와 schema-specialized predicate kernel을 소유합니다. <code>Guard.is()</code>는 per-node interpreter dispatch를 피하려고 kernel을 사용하고, <code>compile()</code>과 <code>emitAotModule()</code>은 optimized graph에서 predicate를 방출합니다. <code>check()</code>는 먼저 같은 plan으로 판정을 얻고, 실패한 값만 schema-aware diagnostic collector로 replay해서 issue path와 code를 만듭니다.</p>
+<pre><code>builder -&gt; frozen schema -&gt; lower -&gt; Sea-of-Nodes IR -&gt; optimize
+optimize -&gt; ValidationPlan { graph, schema kernel }
+schema kernel -&gt; Guard.is() / check() preflight
+graph -&gt; compile() predicate / emitAotModule() predicate / Guard.graph()
+failed check() -&gt; schema-aware diagnostic collector</code></pre>
+<aside class="admonition important"><strong class="admonition-title">IMPORTANT</strong><p>generated validator는 <strong>사용자가 제어하는 값을 소스 문자열에 넣지 않습니다</strong>. literal, regexp, object key, keyset, dynamic schema fallback은 numeric index로 참조되는 <strong>side table</strong>에 둡니다. 적대적인 property name이 generated code 밖으로 탈출할 수 없으며, dedicated injection-audit test가 이 속성을 고정합니다.</p></aside>
+<hr>
+<h3 id="readme-ko-성능-스냅샷">성능 스냅샷</h3>
+<p>마지막 로컬 벤치마크는 2026-07-04 KST에 실행했습니다. <code>npm run bench -- bench/ecosystem.bench.ts --run</code>을 사용했고, benchmark strict-object 계약을 대상으로 했습니다. 아래 값은 단일 머신의 초당 실행 횟수이며 릴리스 성능 보증값은 아닙니다.</p>
+<div class="table-wrap"><table><thead><tr><th>유효한 객체: boolean 경로</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>is()</code></td><td>513,701</td></tr>
+<tr><td>TypeSea compiled safe <code>is()</code></td><td>4,297,306</td></tr>
+<tr><td>TypeSea compiled unsafe <code>is()</code></td><td>36,297,653</td></tr>
+<tr><td>TypeSea compiled unchecked <code>is()</code></td><td>42,581,174</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>1,343,756</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>1,406,528</td></tr>
+<tr><td>Ajv compiled</td><td>4,275,389</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>유효한 객체: 진단 경로</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>check()</code></td><td>503,232</td></tr>
+<tr><td>TypeSea compiled safe <code>check()</code></td><td>3,903,929</td></tr>
+<tr><td>TypeSea compiled unsafe <code>check()</code></td><td>35,568,425</td></tr>
+<tr><td>TypeSea compiled unchecked <code>check()</code></td><td>40,084,605</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>1,355,014</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>1,378,266</td></tr>
+<tr><td>Ajv compiled</td><td>4,278,587</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>잘못된 객체: boolean 경로</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>is()</code></td><td>3,636,369</td></tr>
+<tr><td>TypeSea compiled safe <code>is()</code></td><td>42,080,241</td></tr>
+<tr><td>TypeSea compiled unsafe <code>is()</code></td><td>49,654,076</td></tr>
+<tr><td>TypeSea compiled unchecked <code>is()</code></td><td>50,482,732</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>84,272</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>878,521</td></tr>
+<tr><td>Ajv compiled</td><td>27,820,643</td></tr></tbody></table></div>
+<div class="table-wrap"><table><thead><tr><th>잘못된 객체: 진단 경로</th><th>hz</th></tr></thead><tbody><tr><td>TypeSea interpreted <code>check()</code></td><td>420,446</td></tr>
+<tr><td>TypeSea compiled safe <code>check()</code></td><td>2,086,129</td></tr>
+<tr><td>TypeSea compiled unsafe <code>check()</code></td><td>3,077,367</td></tr>
+<tr><td>TypeSea compiled unchecked <code>check()</code></td><td>3,673,508</td></tr>
+<tr><td>Zod <code>safeParse</code></td><td>79,613</td></tr>
+<tr><td>Valibot <code>safeParse</code></td><td>887,991</td></tr>
+<tr><td>Ajv compiled</td><td>28,713,035</td></tr></tbody></table></div>
+<p>safe compiled path는 TypeSea의 적대적 입력 방어를 유지하면서 Ajv에 가깝게 동작합니다. descriptor 기반 property read, symbol/non-enumerable strict-key rejection, key presence semantics, immutable diagnostics, TypeScript guard inference를 유지합니다. unsafe와 unchecked compiled mode는 그 방어 계약 일부를 의도적으로 포기하기 때문에 더 빠릅니다.</p>
+<hr>
+<h3 id="readme-ko-api-레퍼런스-요약">API 레퍼런스 요약</h3>
+<p>모든 공개 진입점은 package root에서 export됩니다. builder는 <code>t</code> table 아래에도 묶여 있습니다.</p>
+<h4 id="readme-ko-builders">Builders</h4>
+<div class="table-wrap"><table><thead><tr><th>영역</th><th>Entry points</th></tr></thead><tbody><tr><td>Scalar guard</td><td><code>t.unknown</code>, <code>t.never</code>, <code>t.string</code>, <code>t.number</code>, <code>t.date</code>, <code>t.bigint</code>, <code>t.symbol</code>, <code>t.boolean</code>, <code>t.null</code>, <code>t.undefined</code>, <code>t.void</code></td></tr>
+<tr><td>String check</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code>, <code>.regex</code>, <code>.startsWith</code>, <code>.endsWith</code>, <code>.includes</code>, <code>.uuid</code>, <code>.email</code>, <code>.url</code>, <code>.isoDate</code>, <code>.isoDateTime</code>, <code>.ulid</code>, <code>.ipv4</code>, <code>.ipv6</code></td></tr>
+<tr><td>Number check</td><td><code>.int</code>, <code>.finite</code>, <code>.safe</code>, <code>.gte</code>, <code>.lte</code>, <code>.min</code>, <code>.max</code>, <code>.gt</code>, <code>.lt</code>, <code>.multipleOf</code>, <code>.positive</code>, <code>.nonnegative</code>, <code>.negative</code>, <code>.nonpositive</code></td></tr>
+<tr><td>Date check</td><td><code>.min</code>, <code>.max</code></td></tr>
+<tr><td>Literal과 container</td><td><code>t.literal</code>, <code>t.enum</code>, <code>t.array</code>, <code>t.tuple</code>, tuple rest, <code>t.record</code>, <code>t.map</code>, <code>t.set</code>, <code>t.json</code></td></tr>
+<tr><td>Array check</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code></td></tr>
+<tr><td>Object</td><td><code>t.object</code>, <code>t.strictObject</code>, <code>extend</code>, <code>safeExtend</code>, <code>merge</code>, <code>pick</code>, <code>omit</code>, <code>partial</code>, <code>deepPartial</code>, <code>required</code>, <code>strict</code>, <code>passthrough</code>, <code>strip</code>, <code>catchall</code></td></tr>
+<tr><td>Runtime object contract</td><td><code>t.instanceOf</code>, <code>t.property</code>, <code>guard.property</code></td></tr>
+<tr><td>Composition</td><td><code>t.union</code>, <code>t.discriminatedUnion</code>, <code>t.intersect</code>, <code>guard.intersect</code></td></tr>
+<tr><td>Presence wrapper</td><td><code>t.optional</code>, <code>t.undefinedable</code>, <code>t.nullable</code>, <code>t.nullish</code></td></tr>
+<tr><td>Dynamic contract</td><td><code>t.lazy</code>, <code>t.refine</code></td></tr></tbody></table></div>
+<h4 id="readme-ko-decoders">Decoders</h4>
+<div class="table-wrap"><table><thead><tr><th>영역</th><th>Entry points</th></tr></thead><tbody><tr><td>Sync decoder</td><td><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.default</code>, <code>t.defaultValue</code>, <code>t.prefault</code>, <code>t.catch</code>, <code>t.codec</code>, <code>t.coerce</code>, <code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, <code>t.string.toUpperCase()</code></td></tr>
+<tr><td>Async decoder</td><td><code>t.asyncDecoder</code>, <code>t.asyncRefine</code>, <code>t.asyncTransform</code>, <code>t.asyncPipe</code></td></tr></tbody></table></div>
+<h4 id="readme-ko-execution-export">Execution &amp; Export</h4>
+<div class="table-wrap"><table><thead><tr><th>영역</th><th>Entry points</th></tr></thead><tbody><tr><td>Guard method</td><td><code>guard.is()</code>, <code>guard.check()</code>, <code>guard.checkFirst()</code>, <code>guard.graph()</code></td></tr>
+<tr><td>Generated validator</td><td><code>compile</code>, <code>emitAotModule</code></td></tr>
+<tr><td>JSON Schema</td><td><code>toJsonSchema</code></td></tr></tbody></table></div>
+<h4 id="readme-ko-messages-adapters">Messages &amp; Adapters</h4>
+<div class="table-wrap"><table><thead><tr><th>영역</th><th>Entry points</th></tr></thead><tbody><tr><td>Messages / i18n</td><td><code>formatIssue</code>, <code>formatIssues</code>, <code>flattenIssues</code>, <code>withMessages</code>, <code>defineMessages</code></td></tr>
+<tr><td>tRPC</td><td><code>toTrpcParser</code>, <code>toAsyncTrpcParser</code></td></tr>
+<tr><td>Fastify</td><td><code>toFastifyRouteSchema</code>, <code>toFastifyValidatorCompiler</code></td></tr>
+<tr><td>React Hook Form</td><td><code>toReactHookFormResolver</code></td></tr></tbody></table></div>
+<p>adapter도 compiled guard를 받을 수 있습니다. startup에서 한 번 compile한 뒤 parser나 validator-compiler adapter에 넘기면 framework hot path가 generated predicate를 재사용합니다.</p>
+<pre><code>const FastUser = compile(User);
+const trpcParser = toTrpcParser(FastUser);
+const fastifyCompiler = toFastifyValidatorCompiler(FastUser);
+
+// 신뢰된 정규화 데이터 전용: 적대적 입력 방어를 direct read 성능과 맞바꿉니다.
+const UnsafeUser = compile(User, { mode: &quot;unsafe&quot; });
+const internalParser = toTrpcParser(UnsafeUser);</code></pre>
+<aside class="admonition tip"><strong class="admonition-title">TIP</strong><p>source kind에 맞는 inference alias를 쓰세요. guard에는 <code>Infer&lt;&gt;</code>, decoder에는 <code>InferDecoder&lt;&gt;</code>, async decoder에는 <code>InferAsyncDecoder&lt;&gt;</code>를 씁니다. decoder에 <code>Infer&lt;&gt;</code>를 적용하면 <code>never</code>가 됩니다. downstream type이 갑자기 collapse되면 먼저 이 부분을 확인하세요.</p></aside>
+<hr>
+<h3 id="readme-ko-경계-동작">경계 동작</h3>
+<p>의도적으로 정한 동작이며 테스트로 고정되어 있습니다.</p>
+<div class="table-wrap"><table><thead><tr><th>입력</th><th>동작</th></tr></thead><tbody><tr><td><code>NaN</code>, <code>Infinity</code></td><td><code>t.number</code>는 거부합니다. finite number만 허용합니다. <code>t.literal(NaN)</code>은 <code>NaN</code>을 match합니다.</td></tr>
+<tr><td><code>-0</code> vs <code>0</code></td><td>literal은 <code>Object.is</code>로 match합니다. diagnostic은 <code>-0</code>을 구분해서 format합니다.</td></tr>
+<tr><td>Getter-backed properties</td><td>실행하지 않습니다. missing 또는 invalid data로 취급합니다.</td></tr>
+<tr><td><code>__proto__</code>, <code>constructor</code> keys</td><td>pollution 없이 plain own key로 검증합니다.</td></tr>
+<tr><td>Sparse array holes</td><td>accessor 실행 없이 <code>undefined</code>로 읽습니다.</td></tr>
+<tr><td>Strict object extras</td><td><code>Reflect.ownKeys</code>로 거부합니다. symbol key와 non-enumerable property도 포함합니다.</td></tr>
+<tr><td><code>catchall</code> extras</td><td>unknown own key는 descriptor로 읽고 catchall schema로 검증합니다.</td></tr>
+<tr><td><code>strip()</code></td><td>출력 객체를 복사하지 않는 검증 전용 alias입니다. TypeSea에서는 extra key 허용 의미가 <code>passthrough()</code>와 같습니다.</td></tr>
+<tr><td><code>t.date</code></td><td>유효한 JavaScript <code>Date</code> 객체만 허용합니다. <code>.min</code>과 <code>.max</code>는 사용자가 덮어쓸 수 있는 Date method를 읽지 않고 epoch millisecond로 비교합니다.</td></tr>
+<tr><td><code>t.map</code>, <code>t.set</code>, <code>t.instanceOf</code></td><td>runtime-only contract입니다. JSON Schema와 AOT export에서는 의미를 약화시키지 않고 명시적으로 거부합니다.</td></tr>
+<tr><td><code>property</code></td><td>own data property만 검증합니다. getter-backed property는 거부합니다.</td></tr>
+<tr><td>Global-flag regexes</td><td>construction 시 clone하고, 매 test 전에 <code>lastIndex</code>를 reset합니다.</td></tr>
+<tr><td>UUID</td><td>RFC 9562 version 1-8과 nil UUID를 허용합니다.</td></tr>
+<tr><td>Cyclic input values</td><td>value x schema active-pair tracking으로 유한하게 검증합니다.</td></tr>
+<tr><td>Nesting depth</td><td>recursive frame 256에서 cap을 둡니다. 더 깊은 input은 stack overflow 대신 실패합니다.</td></tr></tbody></table></div>
+<hr>
+<h3 id="readme-ko-사용-팁과-주의점">사용 팁과 주의점</h3>
+<aside class="admonition warning"><strong class="admonition-title">WARNING</strong><p><strong>recursive guard에는 명시적 type annotation이 필요합니다.</strong> TypeScript는 self-referential initializer를 추론하지 못합니다(TS7022).</p>
+<pre><code>interface ListNode {
+  readonly value: string;
+  readonly next?: ListNode;
+}
+
+const Node: Guard&lt;ListNode&gt; = t.lazy((): Guard&lt;ListNode&gt; =&gt;
+  t.object({ value: t.string, next: t.optional(Node) })
+);</code></pre></aside>
+<ul><li>**경계 데이터는 <code>unknown</code>으로 들어옵니다.** <code>as</code>로 미리 좁히지 마세요. builder API는 validation을 통해 narrowing이 일어나도록 typed되어 있습니다.</li><li>**recursive contract는 <code>t.lazy</code>를 통합니다.** 직접 순환하는 schema object는 construction에서 거부합니다.</li><li><strong>schema lifetime에 맞춰 engine을 고르세요.</strong> 일회성 schema는 runtime plan, 안정적인 hot schema는 <code>compile()</code>, CSP 환경이나 build-time generation은 <code>emitAotModule()</code>이 맞습니다.</li><li><strong>decoder는 object shape 안에 넣지 않습니다.</strong> decoder를 <code>t.object</code> entry와 섞지 말고, validated shape 바깥에서 <code>t.pipe</code>로 transformation을 합성하세요.</li></ul>
+<hr>
+<h3 id="readme-ko-검증">검증</h3>
+<p>CI가 실행하는 gate는 전부 로컬 npm script입니다.</p>
+<pre><code>npm run check           # policy, docs, typecheck, lint, tests, build, dist, API snapshot, pack
+npm run check:consumer  # tarball install + runtime/type smoke in a temp project
+npm run bench -- --run  # benchmark smoke
+npm run pack:dry        # package contents dry run
+npm run release:check   # the full pre-publish gate</code></pre>
+<p><code>npm run release:check</code>는 publish 전에 기대하는 동일한 gate를 실행합니다. typecheck, lint, tests, build, docs smoke, dist policy, public API snapshot, package contents, consumer install, benchmark smoke, pack dry run을 포함합니다. CI는 Node 20.19, 22, 24에서 실행하고, release는 npm provenance와 함께 publish합니다.</p>
+<aside class="admonition note"><strong class="admonition-title">NOTE</strong><p>benchmark 비교 패키지인 Zod, Valibot, Ajv는 dev dependency일 뿐입니다. package policy는 이들이 runtime dependency field에 들어가는 것을 거부합니다. benchmark suite는 boolean path와 diagnostic path(<code>check()</code> vs <code>safeParse</code>)를 모두 보고하므로 비교 기준을 맞춥니다.</p></aside>
+<hr>
+<h3 id="readme-ko-문서">문서</h3>
+<ul><li><a href="#overview">문서 사이트</a></li><li><a href="#api-reference">API 레퍼런스</a></li><li><a href="#engine-notes">엔진 노트</a></li></ul>
+<hr>
+<h3 id="readme-ko-라이선스">라이선스</h3>
+<p>MIT License. 자세한 내용은 <a href="https://github.com/Feralthedogg/TypeSea/blob/main/LICENSE">LICENSE</a>를 보세요.</p>
+            </div>
+          </article>
+<article id="api-reference" class="source-doc doc-content" data-doc-section>
+            <header>
+              <p class="eyebrow">
+                <span class="i18n-en">API Reference</span>
+                <span class="i18n-ko" lang="ko">API 레퍼런스</span>
+              </p>
+              <h2>
+                <span class="i18n-en">API Reference</span>
+                <span class="i18n-ko" lang="ko">API 레퍼런스</span>
+              </h2>
+              <p>
+                <span class="i18n-en">Rendered from <code>docs/api.md</code>.</span>
+                <span class="i18n-ko" lang="ko"><code>docs/ko/api.md</code>에서 렌더링했습니다.</span>
+              </p>
+            </header>
+            <div class="locale-en">
+<h2 id="api-reference-en-typesea-api-reference">TypeSea API Reference</h2>
+<p>TypeSea accepts untrusted input as <code>unknown</code> and narrows it through immutable guard values. The public API is small by design; most complexity lives behind builder validation, graph introspection, diagnostics, and export checks.</p>
+<h3 id="api-reference-en-import">Import</h3>
+<pre><code>import {
+  compile,
+  emitAotModule,
+  t,
+  toJsonSchema,
+  type Guard,
+  type Infer
+} from &quot;typesea&quot;;</code></pre>
+<p>The package exposes one root entry point. Subpath imports are intentionally not part of the public API. TypeSea is ESM-only and does not publish a CommonJS condition.</p>
+<h3 id="api-reference-en-guard-contract">Guard Contract</h3>
+<pre><code>interface Guard&lt;T&gt; {
+  is(value: unknown): value is T;
+  check(value: unknown): CheckResult&lt;T&gt;;
+  checkFirst(value: unknown): CheckResult&lt;T&gt;;
+  assert(value: unknown): asserts value is T;
+  graph(): Graph;
+}</code></pre>
+<div class="table-wrap"><table><thead><tr><th>Method</th><th>Use it for</th><th>Contract</th></tr></thead><tbody><tr><td><code>is</code></td><td>Hot boolean narrowing</td><td>Avoids diagnostic allocation on the success path.</td></tr>
+<tr><td><code>check</code></td><td>Validation with issues</td><td>Returns frozen <code>Result&lt;T, Issue[]&gt;</code> containers.</td></tr>
+<tr><td><code>checkFirst</code></td><td>Hot rejection diagnostics</td><td>Returns the same frozen <code>Result</code> shape, but failure contains at most one issue. Compiled and AOT guards use a dedicated first-fault collector.</td></tr>
+<tr><td><code>assert</code></td><td>Throwing integration boundaries</td><td>Throws <code>TypeSeaAssertionError</code> with copied, frozen issues.</td></tr>
+<tr><td><code>graph</code></td><td>Runtime plan introspection</td><td>Returns the validated, optimized, frozen Sea-of-Nodes graph held by the validation plan.</td></tr></tbody></table></div>
+<p>Diagnostic paths contain only object keys and zero-based array or tuple indexes. Public diagnostic validators reject malformed path segments before diagnostics cross the API boundary.</p>
+<h3 id="api-reference-en-builder-families">Builder Families</h3>
+<div class="table-wrap"><table><thead><tr><th>Family</th><th>Builders</th></tr></thead><tbody><tr><td>Scalars</td><td><code>t.unknown</code>, <code>t.never</code>, <code>t.string</code>, <code>t.number</code>, <code>t.date</code>, <code>t.bigint</code>, <code>t.symbol</code>, <code>t.boolean</code>, <code>t.null</code>, <code>t.undefined</code>, <code>t.void</code></td></tr>
+<tr><td>String checks</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code>, <code>.regex</code>, <code>.startsWith</code>, <code>.endsWith</code>, <code>.includes</code>, <code>.uuid</code>, <code>.email</code>, <code>.url</code>, <code>.isoDate</code>, <code>.isoDateTime</code>, <code>.ulid</code>, <code>.ipv4</code>, <code>.ipv6</code></td></tr>
+<tr><td>Number checks</td><td><code>.int</code>, <code>.finite</code>, <code>.safe</code>, <code>.gte</code>, <code>.lte</code>, <code>.min</code>, <code>.max</code>, <code>.gt</code>, <code>.lt</code>, <code>.multipleOf</code>, <code>.positive</code>, <code>.nonnegative</code>, <code>.negative</code>, <code>.nonpositive</code></td></tr>
+<tr><td>Date checks</td><td><code>.min</code>, <code>.max</code></td></tr>
+<tr><td>Literals and containers</td><td><code>t.literal(value)</code>, <code>t.enum(values)</code>, <code>t.array(item)</code>, <code>t.tuple([a, b])</code>, <code>t.tuple([head], rest)</code>, <code>t.record(value)</code>, <code>t.map(key, value)</code>, <code>t.set(item)</code>, <code>t.json()</code></td></tr>
+<tr><td>Array checks</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code></td></tr>
+<tr><td>Objects</td><td><code>t.object(shape)</code>, <code>t.strictObject(shape)</code></td></tr>
+<tr><td>Object transforms</td><td><code>t.extend</code>, <code>t.safeExtend</code>, <code>t.merge</code>, <code>t.pick</code>, <code>t.omit</code>, <code>t.partial</code>, <code>t.deepPartial</code>, <code>t.required</code>, <code>t.strict</code>, <code>t.passthrough</code>, <code>t.strip</code>, <code>t.catchall</code>, and matching object guard methods</td></tr>
+<tr><td>Runtime object contracts</td><td><code>t.instanceOf(Ctor)</code>, <code>t.property(base, key, value)</code>, <code>guard.property(key, value)</code></td></tr>
+<tr><td>Composition</td><td><code>t.union</code>, <code>t.discriminatedUnion</code>, <code>t.intersect</code>, <code>guard.intersect</code></td></tr>
+<tr><td>Presence</td><td><code>t.optional</code>, <code>t.undefinedable</code>, <code>t.nullable</code>, <code>t.nullish</code></td></tr>
+<tr><td>Dynamic guards</td><td><code>t.lazy</code>, <code>t.refine</code></td></tr>
+<tr><td>Decoders</td><td><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.default</code>, <code>t.defaultValue</code>, <code>t.prefault</code>, <code>t.catch</code>, <code>t.codec</code>, <code>t.coerce</code>, <code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, <code>t.string.toUpperCase()</code></td></tr>
+<tr><td>Async decoders</td><td><code>t.asyncDecoder</code>, <code>t.asyncRefine</code>, <code>t.asyncTransform</code>, <code>t.asyncPipe</code></td></tr></tbody></table></div>
+<p>Builder functions validate inputs before a schema can enter the validation plan, compiler, AOT emitter, diagnostic collector, or JSON Schema exporter. Forged guard-like values, invalid schema tags, invalid predicates, invalid bounds, malformed regexps, and invalid discriminated union case sets are rejected during construction.</p>
+<p>Accepted schemas are frozen before storage. Public schema collection fields use frozen arrays and frozen key lookup records instead of mutable collection objects.</p>
+<h3 id="api-reference-en-object-presence">Object Presence</h3>
+<p>TypeSea separates key presence from value domain.</p>
+<pre><code>const Shape = t.object({
+  name: t.optional(t.string),
+  nickname: t.undefinedable(t.string)
+});</code></pre>
+<ul><li><code>name</code> may be absent. If <code>name</code> exists, its value must be a string.</li><li><code>nickname</code> must be present. Its value may be a string or <code>undefined</code>.</li><li><code>t.nullable(inner)</code> adds <code>null</code> to the value domain.</li><li><code>t.nullish(inner)</code> combines nullable value semantics with optional object-key</li></ul>
+<p>presence.</p>
+<ul><li>Presence-preserving wrappers keep optional-key semantics through <code>nullable</code>,</li></ul>
+<p><code>undefinedable</code>, <code>brand</code>, and <code>refine</code>.</p>
+<p>Object combinators preserve object mode. Strict object guards remain strict after <code>extend</code>, <code>pick</code>, <code>omit</code>, or <code>partial</code>; passthrough object guards keep allowing unknown keys.</p>
+<p><code>catchall(schema)</code> validates every undeclared own key with <code>schema</code>. <code>strip()</code> is validation-only in TypeSea: guards return the original value, so it has the same validation behavior as <code>passthrough()</code>. <code>pick</code> and <code>omit</code> accept either key arrays or Zod-style <code>{ key: true }</code> masks. <code>deepPartial()</code> recursively partializes pure object, array, tuple, tuple rest, record, map, set, property, union, intersection, nullable, undefinedable, optional, and brand schemas. Lazy and refinement schemas are semantic barriers.</p>
+<p><code>property</code> validates only own data descriptors. It is useful for class instances with stable fields; prototype getters and accessor-backed properties are rejected instead of executed.</p>
+<h3 id="api-reference-en-composition">Composition</h3>
+<p><code>t.union(a, b)</code> accepts a value that satisfies at least one branch.</p>
+<p><code>t.discriminatedUnion(&quot;kind&quot;, cases)</code> requires string case keys. Each case must be a statically inspectable object case whose dispatch key is a required string literal matching the case name.</p>
+<p><code>t.intersect(a, b)</code> and <code>guard.intersect(other)</code> require the same input value to satisfy both guards. <code>check()</code> collects diagnostics from both sides.</p>
+<h3 id="api-reference-en-recursion">Recursion</h3>
+<p>Recursive contracts must use <code>t.lazy</code>.</p>
+<pre><code>interface ListNode {
+  readonly value: string;
+  readonly next?: ListNode;
+}
+
+const Node: Guard&lt;ListNode&gt; = t.lazy((): Guard&lt;ListNode&gt; =&gt;
+  t.object({
+    value: t.string,
+    next: t.optional(Node)
+  })
+);</code></pre>
+<p>Direct cyclic schema objects are rejected at builder boundaries. Lazy guards resolve once per guard instance and keep recursive schema identity stable. A lazy chain must eventually resolve to a concrete non-lazy schema.</p>
+<h3 id="api-reference-en-decoder-pipelines">Decoder Pipelines</h3>
+<pre><code>const Count = t.pipe(t.coerce.number(), t.number.int().gte(0));
+const result = Count.decode(&quot;42&quot;);
+
+const Name = t.default(t.string.min(1), &quot;anonymous&quot;);
+const NumberText = t.codec(
+  t.string.regex(/^\d+$/u, &quot;digits&quot;),
+  t.number.int().nonnegative(),
+  {
+    decode: (value) =&gt; Number(value),
+    encode: (value) =&gt; String(value)
+  }
+);</code></pre>
+<p>Decoders are for output-producing operations. They return <code>Result</code> from <code>decode()</code> and do not expose <code>is()</code> predicates, because the decoded output may not be the same runtime value as the input.</p>
+<ul><li><code>t.transform(source, mapper)</code> decodes <code>source</code>, then maps the decoded value.</li><li><code>t.pipe(source, next)</code> feeds a successful decoded value into the next guard or</li></ul>
+<p>decoder.</p>
+<ul><li><code>t.default(source, value)</code> returns a fallback output for <code>undefined</code> input.</li><li><code>t.prefault(source, value)</code> feeds a fallback input through the source.</li><li><code>t.codec(input, output, mapping)</code> validates both sides of a bidirectional</li></ul>
+<p>decode/encode pair.</p>
+<ul><li><code>t.coerce.string</code>, <code>t.coerce.number</code>, and <code>t.coerce.boolean</code> provide explicit</li></ul>
+<p>primitive coercion.</p>
+<ul><li><code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, and <code>t.string.toUpperCase()</code></li></ul>
+<p>are decoder helpers. They validate the string first, then return transformed output from <code>decode()</code>.</p>
+<ul><li><code>t.asyncRefine</code>, <code>t.asyncTransform</code>, and <code>t.asyncPipe</code> return</li></ul>
+<p><code>Promise&lt;Result&lt;T, Issue[]&gt;&gt;</code> from <code>decodeAsync()</code>.</p>
+<p>Expected async validation failures still return <code>Result</code> values.</p>
+<h3 id="api-reference-en-messages">Messages</h3>
+<pre><code>const checked = withMessages(User.check(input), {
+  locale: &quot;ko&quot;,
+  catalog: defineMessages({
+    expected_string: &quot;{path}: 문자열 필요&quot;
+  })
+});</code></pre>
+<p><code>formatIssue</code>, <code>formatIssues</code>, <code>flattenIssues</code>, and <code>withMessages</code> render diagnostics after validation has finished. This keeps <code>is()</code> and ordinary <code>check()</code> paths free from message allocation.</p>
+<p>Built-in locales are <code>en</code> and <code>ko</code>. Custom catalogs can use string templates with <code>{path}</code>, <code>{code}</code>, <code>{expected}</code>, and <code>{actual}</code>, or formatter callbacks. <code>withMessages(result, options)</code> preserves successful results and returns a new failed <code>Result</code> with copied, frozen issues whose <code>message</code> fields are populated. <code>flattenIssues(issues, options)</code> groups rendered messages into <code>formErrors</code> and top-level <code>fieldErrors</code> buckets.</p>
+<h3 id="api-reference-en-runtime-compile">Runtime Compile</h3>
+<pre><code>const FastUser = compile(User, { name: &quot;isUser&quot; });
+
+FastUser.is(input);
+FastUser.check(input);</code></pre>
+<p><code>compile</code> emits generated predicate functions from the optimized Sea-of-Nodes validation graph plus diagnostics collectors for failed values. Static scalar, object, array, record, union, and strict-key nodes lower to straight-line JavaScript or indexed loops where possible. Dynamic schema edges such as <code>lazy</code> and <code>refine</code> keep semantics by using the same IR-backed runtime fallback as ordinary guards.</p>
+<p>The optional <code>name</code> is a debugging and profiling hint. TypeSea normalizes it into a strict-mode-safe JavaScript function name, prefixes reserved names, and caps generated name length. Direct compiled guard construction validates the predicate, collector, and source arguments. Collector diagnostics are validated, copied, and frozen before <code>check()</code> returns them.</p>
+<p>Generated source never interpolates user-controlled values directly. Literals, regexps, property keys, keysets, and dynamic schema fallbacks are captured in side tables and referenced by numeric index.</p>
+<h4 id="api-reference-en-unsafe-compile-mode">Unsafe Compile Mode</h4>
+<pre><code>const FastButLooseUser = compile(User, {
+  name: &quot;isUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});</code></pre>
+<p><code>CompileOptions[&quot;mode&quot;]</code> and <code>AotCompileOptions[&quot;mode&quot;]</code> are <code>&quot;safe&quot; | &quot;unsafe&quot; | &quot;unchecked&quot; | undefined</code>; omitted options default to <code>&quot;safe&quot;</code>. Safe mode keeps TypeSea's hostile-input contract: descriptor-based property reads, no getter execution, and strict-object rejection for symbol and non-enumerable extras.</p>
+<p>Unsafe mode is an explicit performance escape hatch for trusted, normalized plain data:</p>
+<ul><li>Required object fields read with <code>value[key]</code> when the field schema rejects</li></ul>
+<p><code>undefined</code>.</p>
+<ul><li>Discriminant dispatch reads the tag with direct bracket access.</li><li>Arrays and tuples read items with direct indexed loads.</li><li>Strict-object extra-key rejection uses an allocation-free own-enumerable</li></ul>
+<p><code>for...in</code> loop.</p>
+<p>This may execute getters, may accept prototype-backed values, and does not reject symbol or non-enumerable extras on strict objects. Because compiled <code>check()</code> first trusts the generated predicate verdict, an unsafe predicate that returns <code>true</code> also returns a successful <code>check()</code> result. Use unsafe mode only after the input has crossed a trusted normalization boundary.</p>
+<p>Unsafe mode may embed escaped static property keys directly into generated predicate source so V8 can attach ordinary property-load inline caches. Safe mode keeps property keys in side tables.</p>
+<p>Unchecked mode uses the unsafe direct-read shape and also skips strict-object extra-key loops. It is only for input whose object shape has already been trusted or normalized; strict objects no longer reject extra keys in this mode. Unsafe and unchecked compiled <code>check()</code> calls also return raw successful Result objects without <code>Object.freeze()</code>. Failure diagnostics remain frozen. Safe mode keeps frozen success and failure Result objects. FastMode diagnostic collectors use direct field reads and FastMode strict-key rules for object diagnostics where possible, so missing/accessor issue codes are not guaranteed to match safe mode. Array and tuple diagnostics also use direct indexed reads in fast modes, so sparse slots are diagnosed from the loaded <code>undefined</code> value. Record diagnostics use direct <code>record[key]</code> reads; unchecked mode also visits inherited enumerable keys. Discriminant diagnostics read the tag directly and compare string cases with <code>===</code>.</p>
+<h3 id="api-reference-en-aot-emit">AOT Emit</h3>
+<pre><code>const emitted = emitAotModule(User, { name: &quot;aotUser&quot; });
+const unsafeEmitted = emitAotModule(User, {
+  name: &quot;aotUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});
+const uncheckedEmitted = emitAotModule(User, {
+  name: &quot;aotUserTrustedShape&quot;,
+  mode: &quot;unchecked&quot;
+});</code></pre>
+<p><code>emitAotModule</code> returns <code>Result&lt;AotModule, AotIssue[]&gt;</code>. A successful result contains standalone ESM validator source plus declaration source. The generated module exports <code>is</code>, <code>check</code>, <code>assert</code>, and a default frozen guard-like object, without requiring dynamic source compilation at module load time.</p>
+<p>AOT generation is lossless-only. Schemas that require runtime callbacks or identity that cannot be serialized return explicit AOT issues.</p>
+<h3 id="api-reference-en-ecosystem-adapters">Ecosystem Adapters</h3>
+<pre><code>const parser = toTrpcParser(User);
+const routeSchema = toFastifyRouteSchema(User);
+const validatorCompiler = toFastifyValidatorCompiler(User);
+const resolver = toReactHookFormResolver(User);</code></pre>
+<p>Adapters are structural and zero-dependency. TypeSea does not import tRPC, Fastify, or React Hook Form.</p>
+<p>Compiled guards can be passed to the same adapters. This is the preferred shape for hot request paths: compile once during startup, then let the adapter reuse the generated predicate.</p>
+<pre><code>const FastUser = compile(User);
+const fastParser = toTrpcParser(FastUser);
+const fastValidatorCompiler = toFastifyValidatorCompiler(FastUser);</code></pre>
+<p>Use the default compiled mode at public input boundaries. For trusted, already-normalized internal data, the faster modes can be wired through adapters the same way.</p>
+<pre><code>const UnsafeUser = compile(User, { mode: &quot;unsafe&quot; });
+const internalParser = toTrpcParser(UnsafeUser);
+
+const TrustedShapeUser = compile(User, { mode: &quot;unchecked&quot; });
+const internalValidatorCompiler = toFastifyValidatorCompiler(TrustedShapeUser);</code></pre>
+<div class="table-wrap"><table><thead><tr><th>Adapter</th><th>Export</th><th>Behavior</th></tr></thead><tbody><tr><td>tRPC</td><td><code>toTrpcParser</code>, <code>toAsyncTrpcParser</code></td><td>Return parser objects that emit decoded values or throw <code>TypeSeaAssertionError</code>.</td></tr>
+<tr><td>Fastify route schema</td><td><code>toFastifyRouteSchema</code></td><td>Converts guards to JSON Schema route fragments.</td></tr>
+<tr><td>Fastify validator compiler</td><td><code>toFastifyValidatorCompiler</code></td><td>Returns compiler-shaped validators that produce <code>{ value }</code> or <code>{ error }</code>.</td></tr>
+<tr><td>React Hook Form</td><td><code>toReactHookFormResolver</code></td><td>Returns an async resolver with TypeSea messages mapped to field errors.</td></tr></tbody></table></div>
+<h3 id="api-reference-en-graph-and-ir">Graph and IR</h3>
+<pre><code>const graph = User.graph();
+const optimized = optimizeGraph(graph);</code></pre>
+<p><code>Guard.graph()</code> returns the optimized Sea-of-Nodes validation graph held by the runtime validation plan. The same plan also owns the specialized predicate kernel used by <code>is()</code>. The graph is the source for <code>compile()</code> and <code>emitAotModule()</code>, while the kernel keeps ordinary guard execution out of a generic per-node interpreter. Public graph values are validated, dependency-checked, dense, and frozen.</p>
+<p><code>optimizeGraph(graph)</code> validates direct graph inputs before optimizing them. Regex graph nodes accept only plain <code>RegExp</code> values and store non-extensible regexps, cloning extensible inputs before the graph is frozen.</p>
+<p><code>SchemaCheck</code> records dynamic runtime schema logic such as <code>lazy</code> or <code>refine</code>. It keeps the IR truthful instead of pretending a callback-backed edge is a static primitive.</p>
+<h3 id="api-reference-en-json-schema">JSON Schema</h3>
+<pre><code>const result = toJsonSchema(User);</code></pre>
+<p><code>toJsonSchema</code> returns <code>Result&lt;JsonSchema, JsonSchemaExportIssue[]&gt;</code>. It succeeds only when TypeSea can represent the contract over JSON-compatible input values without semantic loss.</p>
+<p>Runtime-only concepts return explicit export issues:</p>
+<ul><li><code>undefined</code></li><li><code>bigint</code></li><li><code>symbol</code></li><li>JavaScript <code>Date</code>, <code>Map</code>, <code>Set</code>, <code>instanceOf</code>, and <code>property</code> contracts</li><li><code>lazy</code></li><li><code>refine</code></li><li>decoder transforms</li><li>async validation</li><li>regexps with flags</li><li>numeric literals that JSON cannot preserve, such as <code>NaN</code>, <code>Infinity</code>, and</li></ul>
+<p><code>-0</code></p>
+<p><code>schemaToJsonSchema(schema)</code> is the direct schema API. It validates the supplied schema and freezes it before export. JSON Schema options are also validated; <code>schemaId</code>, when present, must be a string.</p>
+<p>Object <code>properties</code> maps are emitted as null-prototype records so special keys such as <code>__proto__</code>, <code>constructor</code>, and <code>hasOwnProperty</code> remain ordinary own schema properties.</p>
+<h3 id="api-reference-en-edge-semantics">Edge Semantics</h3>
+<ul><li>Literal guards use <code>Object.is</code>, so <code>t.literal(Number.NaN)</code> matches <code>NaN</code> and</li></ul>
+<p><code>t.literal(-0)</code> does not match <code>0</code>.</p>
+<ul><li><code>t.number</code> accepts only finite JavaScript numbers. <code>NaN</code>, <code>Infinity</code>, and</li></ul>
+<p><code>-Infinity</code> are rejected before configured numeric predicates run.</p>
+<ul><li>String length bounds must be non-negative integers.</li><li>Numeric comparison bounds must be finite.</li><li>Predicate callbacks must return strict <code>true</code>; truthy non-boolean values do</li></ul>
+<p>not pass validation.</p>
+<ul><li><code>RegExp</code> checks reset <code>lastIndex</code> before each test, so global and sticky</li></ul>
+<p>regexps do not leak state across validations.</p>
+<ul><li>String regex builders and direct string regex schemas accept only plain</li></ul>
+<p><code>RegExp</code> instances. Accepted regex checks are cloned before storage.</p>
+<h3 id="api-reference-en-result-contract">Result Contract</h3>
+<pre><code>type Result&lt;T, E&gt; =
+  | { ok: true; value: T }
+  | { ok: false; error: E };</code></pre>
+<p>Expected validation failures use <code>Result</code>. Result containers are frozen at runtime. Successful values are not recursively frozen because they are caller-owned data.</p>
+            </div>
+            <div class="locale-ko" lang="ko">
+<h2 id="api-reference-ko-typesea-api-레퍼런스">TypeSea API 레퍼런스</h2>
+<p>TypeSea는 신뢰할 수 없는 값을 <code>unknown</code>으로 받고, 불변 guard를 통해 타입을 좁힙니다. 공개 API는 작게 유지하고, 복잡한 검증 로직은 builder validation, graph introspection, diagnostics, export check 내부에 둡니다.</p>
+<h3 id="api-reference-ko-가져오기">가져오기</h3>
+<pre><code>import {
+  compile,
+  emitAotModule,
+  t,
+  toJsonSchema,
+  type Guard,
+  type Infer
+} from &quot;typesea&quot;;</code></pre>
+<p>패키지는 root entry point 하나만 노출합니다. subpath import는 공개 API가 아닙니다. TypeSea는 ESM-only이며 CommonJS condition을 publish하지 않습니다.</p>
+<h3 id="api-reference-ko-guard-계약">Guard 계약</h3>
+<pre><code>interface Guard&lt;T&gt; {
+  is(value: unknown): value is T;
+  check(value: unknown): CheckResult&lt;T&gt;;
+  checkFirst(value: unknown): CheckResult&lt;T&gt;;
+  assert(value: unknown): asserts value is T;
+  graph(): Graph;
+}</code></pre>
+<div class="table-wrap"><table><thead><tr><th>메서드</th><th>용도</th><th>계약</th></tr></thead><tbody><tr><td><code>is</code></td><td>빠른 boolean narrowing</td><td>성공 경로에서 진단 객체를 만들지 않습니다.</td></tr>
+<tr><td><code>check</code></td><td>실패 이유가 필요한 검증</td><td>동결된 <code>Result&lt;T, Issue[]&gt;</code> container를 반환합니다.</td></tr>
+<tr><td><code>checkFirst</code></td><td>hot path의 단일 실패 진단</td><td>같은 <code>Result</code> 형태를 반환하되 실패 시 issue를 최대 하나만 담습니다. compiled/AOT guard는 전용 first-fault collector를 사용합니다.</td></tr>
+<tr><td><code>assert</code></td><td>예외가 필요한 연동 지점</td><td>복사되고 동결된 issue를 담은 <code>TypeSeaAssertionError</code>를 던집니다.</td></tr>
+<tr><td><code>graph</code></td><td>검증 계획 introspection</td><td>validation plan이 보유한 validated, optimized, frozen Sea-of-Nodes graph를 반환합니다.</td></tr></tbody></table></div>
+<p>diagnostic path에는 object key와 0부터 시작하는 array 또는 tuple index만 들어갑니다. 공개 diagnostic validator는 잘못된 path segment를 거부한 뒤 diagnostic을 API 밖으로 내보냅니다.</p>
+<h3 id="api-reference-ko-builder-계열">Builder 계열</h3>
+<div class="table-wrap"><table><thead><tr><th>계열</th><th>Builder</th></tr></thead><tbody><tr><td>Scalar</td><td><code>t.unknown</code>, <code>t.never</code>, <code>t.string</code>, <code>t.number</code>, <code>t.date</code>, <code>t.bigint</code>, <code>t.symbol</code>, <code>t.boolean</code>, <code>t.null</code>, <code>t.undefined</code>, <code>t.void</code></td></tr>
+<tr><td>String check</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code>, <code>.regex</code>, <code>.startsWith</code>, <code>.endsWith</code>, <code>.includes</code>, <code>.uuid</code>, <code>.email</code>, <code>.url</code>, <code>.isoDate</code>, <code>.isoDateTime</code>, <code>.ulid</code>, <code>.ipv4</code>, <code>.ipv6</code></td></tr>
+<tr><td>Number check</td><td><code>.int</code>, <code>.finite</code>, <code>.safe</code>, <code>.gte</code>, <code>.lte</code>, <code>.min</code>, <code>.max</code>, <code>.gt</code>, <code>.lt</code>, <code>.multipleOf</code>, <code>.positive</code>, <code>.nonnegative</code>, <code>.negative</code>, <code>.nonpositive</code></td></tr>
+<tr><td>Date check</td><td><code>.min</code>, <code>.max</code></td></tr>
+<tr><td>Literal과 container</td><td><code>t.literal(value)</code>, <code>t.enum(values)</code>, <code>t.array(item)</code>, <code>t.tuple([a, b])</code>, <code>t.tuple([head], rest)</code>, <code>t.record(value)</code>, <code>t.map(key, value)</code>, <code>t.set(item)</code>, <code>t.json()</code></td></tr>
+<tr><td>Array check</td><td><code>.min</code>, <code>.max</code>, <code>.length</code>, <code>.nonempty</code></td></tr>
+<tr><td>Object</td><td><code>t.object(shape)</code>, <code>t.strictObject(shape)</code></td></tr>
+<tr><td>Object transform</td><td><code>t.extend</code>, <code>t.safeExtend</code>, <code>t.merge</code>, <code>t.pick</code>, <code>t.omit</code>, <code>t.partial</code>, <code>t.deepPartial</code>, <code>t.required</code>, <code>t.strict</code>, <code>t.passthrough</code>, <code>t.strip</code>, <code>t.catchall</code>, 그리고 같은 이름의 object guard method</td></tr>
+<tr><td>Runtime object contract</td><td><code>t.instanceOf(Ctor)</code>, <code>t.property(base, key, value)</code>, <code>guard.property(key, value)</code></td></tr>
+<tr><td>Composition</td><td><code>t.union</code>, <code>t.discriminatedUnion</code>, <code>t.intersect</code>, <code>guard.intersect</code></td></tr>
+<tr><td>Presence</td><td><code>t.optional</code>, <code>t.undefinedable</code>, <code>t.nullable</code>, <code>t.nullish</code></td></tr>
+<tr><td>Dynamic guard</td><td><code>t.lazy</code>, <code>t.refine</code></td></tr>
+<tr><td>Decoder</td><td><code>t.decoder</code>, <code>t.transform</code>, <code>t.pipe</code>, <code>t.default</code>, <code>t.defaultValue</code>, <code>t.prefault</code>, <code>t.catch</code>, <code>t.codec</code>, <code>t.coerce</code>, <code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, <code>t.string.toUpperCase()</code></td></tr>
+<tr><td>Async decoder</td><td><code>t.asyncDecoder</code>, <code>t.asyncRefine</code>, <code>t.asyncTransform</code>, <code>t.asyncPipe</code></td></tr></tbody></table></div>
+<p>builder function은 schema가 validation plan, compiler, AOT emitter, diagnostic collector, JSON Schema exporter로 들어가기 전에 입력을 검증합니다. 위조된 guard-like value, 잘못된 schema tag, 잘못된 predicate, 잘못된 bound, malformed regexp, 잘못된 discriminated union case set은 construction 중 거부됩니다.</p>
+<p>허용된 schema는 저장 전에 freeze됩니다. 공개 schema collection field는 변경 가능한 collection object 대신 frozen array와 frozen key lookup record를 사용합니다.</p>
+<h3 id="api-reference-ko-객체-key-존재-규칙">객체 key 존재 규칙</h3>
+<p>TypeSea는 key가 존재하는지와 value domain을 분리합니다.</p>
+<pre><code>const Shape = t.object({
+  name: t.optional(t.string),
+  nickname: t.undefinedable(t.string)
+});</code></pre>
+<ul><li><code>name</code>은 없어도 됩니다. 존재한다면 값은 string이어야 합니다.</li><li><code>nickname</code>은 반드시 존재해야 합니다. 값은 string 또는 <code>undefined</code>일 수 있습니다.</li><li><code>t.nullable(inner)</code>는 value domain에 <code>null</code>을 추가합니다.</li><li><code>t.nullish(inner)</code>는 nullable value와 optional key 의미를 함께 제공합니다.</li><li><code>nullable</code>, <code>undefinedable</code>, <code>brand</code>, <code>refine</code>을 지나도 optional-key 의미는 보존됩니다.</li></ul>
+<p>object combinator는 object mode를 보존합니다. strict object guard는 <code>extend</code>, <code>pick</code>, <code>omit</code>, <code>partial</code> 이후에도 strict를 유지하고, passthrough object guard는 unknown key 허용을 유지합니다.</p>
+<p><code>catchall(schema)</code>는 선언되지 않은 모든 own key를 <code>schema</code>로 검증합니다. <code>strip()</code>은 TypeSea에서 검증 전용 의미입니다. guard는 원본 값을 반환하므로, 검증 의미는 <code>passthrough()</code>와 같습니다. <code>pick</code>과 <code>omit</code>은 key array와 Zod 스타일 <code>{ key: true }</code> mask를 모두 받습니다. <code>deepPartial()</code>은 순수 object, array, tuple, tuple rest, record, map, set, property, union, intersection, nullable, undefinedable, optional, brand schema를 재귀적으로 partial 처리합니다. lazy와 refinement schema는 callback 의미를 보존하기 위해 semantic barrier로 둡니다.</p>
+<p><code>property</code>는 own data descriptor만 검증합니다. 안정적인 class field를 증명할 때 쓰기 좋고, prototype getter나 accessor property는 실행하지 않고 거부합니다.</p>
+<h3 id="api-reference-ko-합성">합성</h3>
+<p><code>t.union(a, b)</code>는 적어도 한 branch를 만족하는 값을 허용합니다.</p>
+<p><code>t.discriminatedUnion(&quot;kind&quot;, cases)</code>는 string case key를 요구합니다. 각 case는 static하게 inspect할 수 있는 object case여야 하며, dispatch key는 case name과 일치하는 required string literal이어야 합니다.</p>
+<p><code>t.intersect(a, b)</code>와 <code>guard.intersect(other)</code>는 같은 input value가 두 guard를 모두 만족해야 합니다. <code>check()</code>는 양쪽 diagnostic을 모두 수집합니다.</p>
+<h3 id="api-reference-ko-재귀">재귀</h3>
+<p>recursive contract는 반드시 <code>t.lazy</code>를 사용해야 합니다.</p>
+<pre><code>interface ListNode {
+  readonly value: string;
+  readonly next?: ListNode;
+}
+
+const Node: Guard&lt;ListNode&gt; = t.lazy((): Guard&lt;ListNode&gt; =&gt;
+  t.object({
+    value: t.string,
+    next: t.optional(Node)
+  })
+);</code></pre>
+<p>직접 순환하는 schema object는 builder boundary에서 거부됩니다. lazy guard는 guard instance마다 한 번 resolve되고 recursive schema identity를 안정적으로 유지합니다. lazy chain은 결국 concrete non-lazy schema로 resolve되어야 합니다.</p>
+<h3 id="api-reference-ko-decoder-pipeline">Decoder Pipeline</h3>
+<pre><code>const Count = t.pipe(t.coerce.number(), t.number.int().gte(0));
+const result = Count.decode(&quot;42&quot;);
+
+const Name = t.default(t.string.min(1), &quot;anonymous&quot;);
+const NumberText = t.codec(
+  t.string.regex(/^\d+$/u, &quot;digits&quot;),
+  t.number.int().nonnegative(),
+  {
+    decode: (value) =&gt; Number(value),
+    encode: (value) =&gt; String(value)
+  }
+);</code></pre>
+<p>decoder는 output을 생성하는 작업에 씁니다. <code>decode()</code>에서 <code>Result</code>를 반환하며 <code>is()</code> predicate를 노출하지 않습니다. decoded output이 input과 같은 runtime value가 아닐 수 있기 때문입니다.</p>
+<ul><li><code>t.transform(source, mapper)</code>는 <code>source</code>를 decode한 뒤 decoded value를 map합니다.</li><li><code>t.pipe(source, next)</code>는 성공한 decoded value를 다음 guard 또는 decoder에 넘깁니다.</li><li><code>t.default(source, value)</code>는 input이 <code>undefined</code>일 때 fallback output을 바로 반환합니다.</li><li><code>t.prefault(source, value)</code>는 input이 <code>undefined</code>일 때 fallback input을 source에 다시 통과시킵니다.</li><li><code>t.codec(input, output, mapping)</code>은 bidirectional decode/encode 양쪽을 모두 검증합니다.</li><li><code>t.coerce.string</code>, <code>t.coerce.number</code>, <code>t.coerce.boolean</code>은 명시적 primitive coercion을 제공합니다.</li><li><code>t.string.trim()</code>, <code>t.string.toLowerCase()</code>, <code>t.string.toUpperCase()</code>는 decoder helper입니다. 먼저 string을 검증한 뒤 <code>decode()</code> 결과로 변환된 값을 반환합니다.</li><li><code>t.asyncRefine</code>, <code>t.asyncTransform</code>, <code>t.asyncPipe</code>는 <code>decodeAsync()</code>에서 <code>Promise&lt;Result&lt;T, Issue[]&gt;&gt;</code>를 반환합니다.</li></ul>
+<p>예상 가능한 async validation 실패도 <code>Result</code>로 반환됩니다.</p>
+<h3 id="api-reference-ko-message">Message</h3>
+<pre><code>const checked = withMessages(User.check(input), {
+  locale: &quot;ko&quot;,
+  catalog: defineMessages({
+    expected_string: &quot;{path}: 문자열 필요&quot;
+  })
+});</code></pre>
+<p><code>formatIssue</code>, <code>formatIssues</code>, <code>flattenIssues</code>, <code>withMessages</code>는 validation이 끝난 뒤 diagnostic을 렌더링합니다. 따라서 <code>is()</code>와 일반 <code>check()</code> path에서는 message allocation이 발생하지 않습니다.</p>
+<p>built-in locale은 <code>en</code>과 <code>ko</code>입니다. custom catalog는 <code>{path}</code>, <code>{code}</code>, <code>{expected}</code>, <code>{actual}</code> string template 또는 formatter callback을 쓸 수 있습니다. <code>withMessages(result, options)</code>는 successful result를 그대로 보존하고, failed <code>Result</code>에는 복사되고 동결된 issue에 <code>message</code> field를 채워 새로 반환합니다. <code>flattenIssues(issues, options)</code>는 렌더링된 message를 <code>formErrors</code>와 top-level <code>fieldErrors</code> bucket으로 묶습니다.</p>
+<h3 id="api-reference-ko-런타임-컴파일">런타임 컴파일</h3>
+<pre><code>const FastUser = compile(User, { name: &quot;isUser&quot; });
+
+FastUser.is(input);
+FastUser.check(input);</code></pre>
+<p><code>compile</code>은 optimized Sea-of-Nodes validation graph에서 generated predicate function과 failed value용 diagnostic collector를 방출합니다. static scalar, object, array, record, union, strict-key node는 가능한 경우 straight-line JavaScript 또는 indexed loop로 낮아집니다. <code>lazy</code>, <code>refine</code> 같은 dynamic schema edge는 ordinary guard execution과 같은 IR-backed runtime fallback을 사용해 의미를 유지합니다.</p>
+<p>선택적 <code>name</code>은 debugging과 profiling을 위한 hint입니다. TypeSea는 이를 strict-mode-safe JavaScript function name으로 normalize하고, reserved name에는 prefix를 붙이며, generated name 길이에 cap을 둡니다. 직접 compiled guard construction은 predicate, collector, source argument를 검증합니다. collector diagnostic은 <code>check()</code> 반환 전에 validate, copy, freeze됩니다.</p>
+<p>generated source는 사용자가 제어하는 값을 직접 interpolate하지 않습니다. literal, regexp, property key, keyset, dynamic schema fallback은 side table에 capture되고 numeric index로 참조됩니다.</p>
+<h4 id="api-reference-ko-unsafe-컴파일-모드">Unsafe 컴파일 모드</h4>
+<pre><code>const FastButLooseUser = compile(User, {
+  name: &quot;isUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});</code></pre>
+<p><code>CompileOptions[&quot;mode&quot;]</code>와 <code>AotCompileOptions[&quot;mode&quot;]</code>는 <code>&quot;safe&quot; | &quot;unsafe&quot; | &quot;unchecked&quot; | undefined</code>입니다. option을 생략하면 <code>&quot;safe&quot;</code>가 기본입니다. safe mode는 TypeSea의 적대적 입력 방어 계약을 유지합니다. descriptor 기반 property read, getter 실행 금지, symbol과 non-enumerable extra를 포함한 strict-object rejection을 보장합니다.</p>
+<p>unsafe mode는 신뢰할 수 있고 정규화된 plain data를 위한 명시적 performance escape hatch입니다.</p>
+<ul><li>field schema가 <code>undefined</code>를 거부하는 required object field는 <code>value[key]</code>로 읽습니다.</li><li>discriminant dispatch는 tag를 direct bracket access로 읽습니다.</li><li>array와 tuple은 direct indexed load를 사용합니다.</li><li>strict-object extra-key rejection은 allocation-free own-enumerable <code>for...in</code> loop를 사용합니다.</li></ul>
+<p>이 모드는 getter를 실행할 수 있고, prototype-backed value를 받아들일 수 있으며, strict object에서 symbol 또는 non-enumerable extra를 거부하지 않습니다. compiled <code>check()</code>는 먼저 generated predicate의 판정을 신뢰하므로, unsafe predicate가 <code>true</code>를 반환하면 <code>check()</code>도 successful result를 반환합니다. input이 trusted normalization boundary를 지난 뒤에만 unsafe mode를 사용하세요.</p>
+<p>unsafe mode는 escaped static property key를 generated predicate source에 직접 넣을 수 있습니다. 그래야 V8이 ordinary property-load inline cache를 붙이기 쉽습니다. safe mode는 property key를 side table에 유지합니다.</p>
+<p>unchecked mode는 unsafe direct-read shape을 사용하고 strict-object extra-key loop도 건너뜁니다. object shape이 이미 신뢰되거나 정규화된 input에만 사용해야 합니다. 이 모드에서는 strict object가 더 이상 extra key를 거부하지 않습니다.</p>
+<p>unsafe와 unchecked compiled <code>check()</code>는 successful Result object를 <code>Object.freeze()</code> 없이 raw object로 반환합니다. failure diagnostic은 계속 freeze됩니다. safe mode는 success와 failure 모두 frozen Result object를 유지합니다. FastMode diagnostic collector는 가능한 경우 direct field read와 FastMode strict-key rule을 사용합니다. 따라서 missing/accessor issue code는 safe mode와 일치한다고 보장하지 않습니다. array와 tuple diagnostic도 fast mode에서는 direct indexed read를 쓰므로 sparse slot은 loaded <code>undefined</code> value 기준으로 진단됩니다. record diagnostic은 direct <code>record[key]</code> read를 사용합니다. unchecked mode는 inherited enumerable key도 방문합니다. discriminant diagnostic은 tag를 직접 읽고 string case를 <code>===</code>로 비교합니다.</p>
+<h3 id="api-reference-ko-aot-모듈-생성">AOT 모듈 생성</h3>
+<pre><code>const emitted = emitAotModule(User, { name: &quot;aotUser&quot; });
+const unsafeEmitted = emitAotModule(User, {
+  name: &quot;aotUserFast&quot;,
+  mode: &quot;unsafe&quot;
+});
+const uncheckedEmitted = emitAotModule(User, {
+  name: &quot;aotUserTrustedShape&quot;,
+  mode: &quot;unchecked&quot;
+});</code></pre>
+<p><code>emitAotModule</code>은 <code>Result&lt;AotModule, AotIssue[]&gt;</code>를 반환합니다. successful result에는 standalone ESM validator source와 declaration source가 들어 있습니다. generated module은 module load time에 dynamic source compilation을 요구하지 않고 <code>is</code>, <code>check</code>, <code>assert</code>, default frozen guard-like object를 export합니다.</p>
+<p>AOT generation은 lossless-only입니다. runtime callback 또는 serialize할 수 없는 identity가 필요한 schema는 명시적 AOT issue를 반환합니다.</p>
+<h3 id="api-reference-ko-framework-adapter">Framework Adapter</h3>
+<pre><code>const parser = toTrpcParser(User);
+const routeSchema = toFastifyRouteSchema(User);
+const validatorCompiler = toFastifyValidatorCompiler(User);
+const resolver = toReactHookFormResolver(User);</code></pre>
+<p>adapter는 구조적으로 맞춰진 얇은 연결 계층이며 런타임 의존성이 없습니다. TypeSea는 tRPC, Fastify, React Hook Form을 import하지 않습니다.</p>
+<p>compiled guard도 같은 adapter에 넘길 수 있습니다. hot request path에서는 이 형태를 권장합니다. startup에서 한 번 compile한 뒤 adapter가 generated predicate를 재사용하게 하세요.</p>
+<pre><code>const FastUser = compile(User);
+const fastParser = toTrpcParser(FastUser);
+const fastValidatorCompiler = toFastifyValidatorCompiler(FastUser);</code></pre>
+<p>public input boundary에서는 기본 compiled mode를 쓰세요. 신뢰된, 이미 정규화된 내부 데이터에서는 더 빠른 mode를 같은 방식으로 adapter에 연결할 수 있습니다.</p>
+<pre><code>const UnsafeUser = compile(User, { mode: &quot;unsafe&quot; });
+const internalParser = toTrpcParser(UnsafeUser);
+
+const TrustedShapeUser = compile(User, { mode: &quot;unchecked&quot; });
+const internalValidatorCompiler = toFastifyValidatorCompiler(TrustedShapeUser);</code></pre>
+<div class="table-wrap"><table><thead><tr><th>Adapter</th><th>Export</th><th>동작</th></tr></thead><tbody><tr><td>tRPC</td><td><code>toTrpcParser</code>, <code>toAsyncTrpcParser</code></td><td>decoded value를 반환하거나 <code>TypeSeaAssertionError</code>를 던지는 parser object를 반환합니다.</td></tr>
+<tr><td>Fastify route schema</td><td><code>toFastifyRouteSchema</code></td><td>guard를 JSON Schema route fragment로 변환합니다.</td></tr>
+<tr><td>Fastify validator compiler</td><td><code>toFastifyValidatorCompiler</code></td><td><code>{ value }</code> 또는 <code>{ error }</code>를 만드는 compiler-shaped validator를 반환합니다.</td></tr>
+<tr><td>React Hook Form</td><td><code>toReactHookFormResolver</code></td><td>TypeSea message를 field error로 매핑하는 async resolver를 반환합니다.</td></tr></tbody></table></div>
+<h3 id="api-reference-ko-graph-and-ir">Graph and IR</h3>
+<pre><code>const graph = User.graph();
+const optimized = optimizeGraph(graph);</code></pre>
+<p><code>Guard.graph()</code>는 runtime validation plan이 보유한 optimized Sea-of-Nodes validation graph를 반환합니다. 같은 plan은 <code>is()</code>가 사용하는 specialized predicate kernel도 소유합니다. graph는 <code>compile()</code>과 <code>emitAotModule()</code>의 source이고, kernel은 ordinary guard execution이 generic per-node interpreter를 타지 않게 합니다. 공개 graph value는 validate, dependency-check, dense compaction, freeze를 거쳐 반환됩니다.</p>
+<p><code>optimizeGraph(graph)</code>는 직접 전달된 graph input을 validate한 뒤 optimize합니다. regex graph node는 plain <code>RegExp</code> value만 받으며, graph가 freeze되기 전에 extensible input을 clone해서 non-extensible regexp로 저장합니다.</p>
+<p><code>SchemaCheck</code>는 <code>lazy</code>나 <code>refine</code>처럼 dynamic runtime schema logic을 기록합니다. callback-backed edge를 static primitive인 척하지 않고, runtime semantics가 필요하다는 사실을 IR에 정확히 남깁니다.</p>
+<h3 id="api-reference-ko-json-schema-내보내기">JSON Schema 내보내기</h3>
+<pre><code>const result = toJsonSchema(User);</code></pre>
+<p><code>toJsonSchema</code>는 <code>Result&lt;JsonSchema, JsonSchemaExportIssue[]&gt;</code>를 반환합니다. TypeSea가 JSON-compatible input value 위에서 contract를 의미 손실 없이 표현할 수 있을 때만 성공합니다.</p>
+<p>runtime-only concept는 명시적 export issue를 반환합니다.</p>
+<ul><li><code>undefined</code></li><li><code>bigint</code></li><li><code>symbol</code></li><li>JavaScript <code>Date</code>, <code>Map</code>, <code>Set</code>, <code>instanceOf</code>, <code>property</code> contract</li><li><code>lazy</code></li><li><code>refine</code></li><li>decoder transforms</li><li>async validation</li><li>flag가 있는 regexp</li><li><code>NaN</code>, <code>Infinity</code>, <code>-0</code>처럼 JSON이 보존할 수 없는 numeric literal</li></ul>
+<p><code>schemaToJsonSchema(schema)</code>는 direct schema API입니다. 전달된 schema를 validate하고 freeze한 뒤 export합니다. JSON Schema option도 validate합니다. <code>schemaId</code>가 있으면 string이어야 합니다.</p>
+<p>object <code>properties</code> map은 null-prototype record로 방출됩니다. 따라서 <code>__proto__</code>, <code>constructor</code>, <code>hasOwnProperty</code> 같은 특수 key도 ordinary own schema property로 남습니다.</p>
+<h3 id="api-reference-ko-경계-동작">경계 동작</h3>
+<ul><li>literal guard는 <code>Object.is</code>를 사용합니다. 따라서 <code>t.literal(Number.NaN)</code>은 <code>NaN</code>을 match하고 <code>t.literal(-0)</code>은 <code>0</code>과 match하지 않습니다.</li><li><code>t.number</code>는 finite JavaScript number만 허용합니다. <code>NaN</code>, <code>Infinity</code>, <code>-Infinity</code>는 configured numeric predicate가 실행되기 전에 거부됩니다.</li><li>string length bound는 non-negative integer여야 합니다.</li><li>numeric comparison bound는 finite number여야 합니다.</li><li>predicate callback은 strict <code>true</code>를 반환해야 합니다. truthy non-boolean value는 validation을 통과하지 않습니다.</li><li><code>RegExp</code> check는 매 test 전에 <code>lastIndex</code>를 reset합니다. global과 sticky regexp의 상태가 validation 사이에 새지 않습니다.</li><li>string regex builder와 direct string regex schema는 plain <code>RegExp</code> instance만 받습니다. 허용된 regex check는 storage 전에 clone됩니다.</li></ul>
+<h3 id="api-reference-ko-result-계약">Result 계약</h3>
+<pre><code>type Result&lt;T, E&gt; =
+  | { ok: true; value: T }
+  | { ok: false; error: E };</code></pre>
+<p>예상 가능한 validation failure는 <code>Result</code>를 사용합니다. Result container는 runtime에서 freeze됩니다. successful value는 caller-owned data이므로 recursive freeze하지 않습니다.</p>
+            </div>
+          </article>
+<article id="engine-notes" class="source-doc doc-content" data-doc-section>
+            <header>
+              <p class="eyebrow">
+                <span class="i18n-en">Engine Notes</span>
+                <span class="i18n-ko" lang="ko">엔진 설계 노트</span>
+              </p>
+              <h2>
+                <span class="i18n-en">Engine Notes</span>
+                <span class="i18n-ko" lang="ko">엔진 설계 노트</span>
+              </h2>
+              <p>
+                <span class="i18n-en">Rendered from <code>docs/engine-notes.md</code>.</span>
+                <span class="i18n-ko" lang="ko"><code>docs/ko/engine-notes.md</code>에서 렌더링했습니다.</span>
+              </p>
+            </header>
+            <div class="locale-en">
+<h2 id="engine-notes-en-engine-notes">Engine Notes</h2>
+<p>TypeSea is written for predictable machine behavior after TypeScript emits JavaScript. The goal is not obscurity; the goal is to make object shapes, allocation sites, branch behavior, and validation contracts visible in code.</p>
+<h3 id="engine-notes-en-hot-path-rules">Hot Path Rules</h3>
+<ul><li>Use prototype methods instead of per-instance method closures.</li><li>Use numeric tags for schema, check, issue, and IR node variants.</li><li>Initialize class fields in one constructor order.</li><li>Keep successful <code>is()</code> validation free of diagnostic allocation.</li><li>Allocate <code>Issue</code> objects and path arrays only when diagnostics are requested.</li><li>Prefer indexed loops on recursive validation paths.</li><li>Precompute object-entry arrays during schema construction.</li><li>After required object fields have proved their data-property descriptors, load</li></ul>
+<p>descriptor values directly instead of rechecking missing-property fallbacks.</p>
+<ul><li>For all-required strict objects, reject extras by counting own string names</li></ul>
+<p>and own symbols after field validation. Optional strict objects keep the full key membership scan.</p>
+<ul><li>Keep <code>compile()</code> and <code>emitAotModule()</code> safe by default. Unsafe mode is an</li></ul>
+<p>explicit opt-in that may use direct property/index loads and own-enumerable strict-key loops after the caller accepts getter/prototype/symbol-extra risk.</p>
+<ul><li>Mark constructed guards out-of-band so normal receivers avoid repeated schema</li></ul>
+<p>validation while forged receivers still fall back to structural checks.</p>
+<ul><li>Use <code>Readonly&lt;Record&lt;string, unknown&gt;&gt;</code> after object guards.</li><li>Store generated-validator literals, regexps, keysets, and dynamic fallbacks in</li></ul>
+<p>side tables instead of interpolating user-controlled values into source text.</p>
+<h3 id="engine-notes-en-type-system-rules">Type-System Rules</h3>
+<ul><li><code>optional(inner)</code> means an object key may be absent.</li><li><code>undefinedable(inner)</code> means the key must exist when used in an object shape,</li></ul>
+<p>but its value may be <code>undefined</code>.</p>
+<ul><li><code>nullable(inner)</code> means the value may be <code>null</code>.</li><li>Presence-preserving wrappers do not erase optional-key semantics.</li><li><code>number</code> means finite JavaScript number.</li><li><code>unknown</code> is the only accepted boundary type for untrusted input.</li><li>Builder validation is the hard barrier before a schema reaches the engine.</li></ul>
+<h3 id="engine-notes-en-ir-rules">IR Rules</h3>
+<p>The public schema tree is the semantic source used by builders and diagnostic collectors. Boolean validation executes a cached <code>ValidationPlan</code>: schema identity is lowered into Sea-of-Nodes IR, the optimizer runs, and the plan keeps both the frozen graph and a schema-specialized predicate kernel.</p>
+<p>The graph is not decorative. <code>compile()</code>, AOT emission, and <code>Guard.graph()</code> all consume the optimized graph held by the plan. Ordinary <code>Guard.is()</code> deliberately uses the sibling schema-specialized kernel instead of a generic node interpreter, because per-node dispatch and scratch-slot bookkeeping cost more than they buy on the most common hot path.</p>
+<p>Current lowering hash-conses pure value and predicate nodes. Strict object schemas lower an explicit keyset check into the IR, so extra-key rejection does not depend on out-of-band schema knowledge. Required and optional object fields separate key presence from data-property presence, which keeps accessor-backed properties from executing getters or being misclassified as valid values.</p>
+<p><code>Guard.graph()</code> returns the same optimized graph held by the validation plan. Public graph values are validated and frozen before leaving the API. The first optimizer pass performs reachable node elimination and compacts node ids so every dependency points at an existing dense node index. <code>compile()</code> and AOT emission use this graph as their predicate source.</p>
+<p>Array, tuple, and record schemas lower to native composite IR nodes whose child schemas are executed through child validation plans. <code>SchemaCheck</code> is reserved for dynamic schemas such as <code>lazy</code> and <code>refine</code>; the graph records that callback or resolver-backed semantics are required instead of pretending they are static predicates.</p>
+<h3 id="engine-notes-en-runtime-compiler">Runtime Compiler</h3>
+<p>Compiled guards emit boolean predicates from optimized Sea-of-Nodes graphs and schema-aware diagnostics collectors for failed values. Runtime <code>is()</code> uses the plan-owned schema-specialized kernel to avoid recursive node dispatch and scratch buffer churn. <code>check()</code> first asks the plan predicate for the pass/fail verdict; successful values skip diagnostic collection, while failed values replay the diagnostic collector to build paths and issue codes.</p>
+<p>User-controlled literals, regexps, object keys, keysets, dynamic schemas, and diagnostic names live in side tables captured by the generated factory. The generated source contains numeric side-table indexes, fixed helper strings, and sanitized function names.</p>
+<p>Scalar nodes emit direct JavaScript tests where the semantics are local: finite-number checks, integer checks, string length bounds, literal equality, and regexp tests all lower without helper calls on the generated hot path.</p>
+<p>Array and record IR nodes emit indexed loops. Static child schemas are inlined into those loops from their optimized graphs, which avoids function-call boundaries for small scalar or union element contracts. Tuple nodes preserve descriptor-based element access, and dynamic edges use the same IR-backed runtime fallback as ordinary guard execution, preserving behavior for <code>lazy</code> and <code>refine</code>.</p>
+<p>Strict object IR emits two shapes. When every declared key is required, generated validators run the strict-key count before field descriptor reads: they compare <code>Object.getOwnPropertyNames(value).length</code> with the declared key count and require <code>Object.getOwnPropertySymbols(value).length === 0</code>. V8 optimizes this count-only path better than a generic <code>Reflect.ownKeys</code> count, and it rejects obvious extra-key objects before touching field descriptors. Optional strict objects still emit the full own-key membership scan because a missing optional key cannot be distinguished by the final key count alone.</p>
+<p><code>compile(..., { mode: &quot;unsafe&quot; })</code> and <code>emitAotModule(..., { mode: &quot;unsafe&quot; })</code> switch generated predicates to a trusted-data code shape. Required object fields whose schemas reject <code>undefined</code> use direct <code>value[key]</code> loads without descriptor or own-key checks. Required fields that can accept <code>undefined</code> retain an own-key presence guard so missing required keys do not collapse into valid <code>undefined</code> values. Optional fields take the direct-load fast path for present non-<code>undefined</code> values and fall back to an own-key check only for the ambiguous <code>undefined</code> case.</p>
+<p>Unsafe array, tuple, record, and discriminant paths also prefer direct loads. Strict objects use a <code>for...in</code> own-enumerable key loop instead of allocating own-key arrays. Object keys that are ASCII identifier names emit as dot-property loads such as <code>value.id</code>; other keys emit as escaped string-literal bracket loads. That is intentionally not hostile-input equivalent: getters can execute, prototype-backed values can be accepted, symbol or non-enumerable strict extras are not rejected, and static property names may appear in unsafe generated predicate source.</p>
+<p><code>mode: &quot;unchecked&quot;</code> keeps the unsafe direct-read shape and removes strict extra-key loops. It is a trusted-shape path for objects already normalized by the caller; strict objects no longer reject any extra keys there.</p>
+<p>Fast modes also remove <code>Object.freeze()</code> from successful compiled <code>check()</code> results. The returned object keeps the same <code>{ ok: true, value }</code> shape, but it is intentionally not frozen. Failed diagnostics stay frozen because those objects are off the success hot path and are often retained for reporting. Object diagnostics in fast modes are generated from the same direct-read contract as predicates. Required fields load through <code>value.key</code>, optional fields use direct load plus an own-key fallback for <code>undefined</code>, unsafe strict objects scan own enumerable string keys, and unchecked strict objects skip the strict-key diagnostic scan. Array and tuple diagnostics in fast modes read items through direct indexes instead of descriptor probes. Record diagnostics read through <code>record[key]</code>; unchecked mode intentionally keeps inherited enumerable keys visible. Discriminant diagnostics read the tag directly and compare literal string cases with strict equality.</p>
+<h3 id="engine-notes-en-recursion">Recursion</h3>
+<p>Lazy schemas resolve their getter once per guard instance. Recursive validation therefore sees stable schema identity, and repeated validations do not rebuild the recursive schema graph.</p>
+<p>Recursive validation uses a root-local active pair table keyed by runtime object identity and schema identity. Re-entering the same schema/value pair short-circuits that edge, which lets cyclic object graphs validate finitely while still checking the original object fields on the outer frame.</p>
+<p>Compiled <code>lazy</code> and <code>refine</code> fallbacks use the same IR-backed runtime path, so recursive behavior stays consistent across execution engines.</p>
+<p><code>checkFirst()</code> has a separate generated collector. It returns one frozen issue as soon as the first diagnostic is known, instead of running the full <code>check()</code> collector and truncating its issue array.</p>
+<h3 id="engine-notes-en-json-schema-export">JSON Schema Export</h3>
+<p>JSON Schema export succeeds only when the TypeSea schema can be represented over JSON-compatible input values without semantic loss. Runtime-only concepts return typed <code>Result</code> errors.</p>
+<p>Export diagnostics keep paths at the failed child slot instead of collapsing everything to the parent container. Nested unsupported schemas therefore remain actionable without reconstructing the schema tree manually.</p>
+<p>Literal checks use <code>Object.is</code> in runtime-plan and compiled paths. Diagnostics use the same literal formatting, including <code>-0</code>, so compiled and runtime-plan <code>check()</code> results stay byte-for-byte comparable in tests.</p>
+<h3 id="engine-notes-en-benchmark-scope">Benchmark Scope</h3>
+<p>The benchmark suite keeps two questions separate:</p>
+<ul><li><code>compile.bench.ts</code> compares TypeSea runtime-plan and compiled validators over</li></ul>
+<p>the same TypeSea schema.</p>
+<ul><li><code>ecosystem.bench.ts</code> compares TypeSea runtime-plan, TypeSea compiled, Zod,</li></ul>
+<p>Valibot, and Ajv over one JSON-compatible strict-object contract.</p>
+<p>Zod, Valibot, and Ajv are dev dependencies for measurement only. They are not imported by <code>src</code>, and package policy rejects runtime, peer, optional, or bundled dependency fields before release.</p>
+<p>Last local benchmark on 2026-07-04 KST reported these ecosystem paths over the JSON-compatible strict-object benchmark:</p>
+<div class="table-wrap"><table><thead><tr><th>Case</th><th>TypeSea runtime plan</th><th>TypeSea compiled safe</th><th>TypeSea compiled unsafe</th><th>TypeSea compiled unchecked</th><th>Ajv compiled</th></tr></thead><tbody><tr><td>Valid <code>is()</code></td><td>513,701 hz</td><td>4,297,306 hz</td><td>36,297,653 hz</td><td>42,581,174 hz</td><td>4,275,389 hz</td></tr>
+<tr><td>Valid <code>check()</code></td><td>503,232 hz</td><td>3,903,929 hz</td><td>35,568,425 hz</td><td>40,084,605 hz</td><td>4,278,587 hz</td></tr>
+<tr><td>Invalid <code>is()</code></td><td>3,636,369 hz</td><td>42,080,241 hz</td><td>49,654,076 hz</td><td>50,482,732 hz</td><td>27,820,643 hz</td></tr>
+<tr><td>Invalid <code>check()</code></td><td>420,446 hz</td><td>2,086,129 hz</td><td>3,077,367 hz</td><td>3,673,508 hz</td><td>28,713,035 hz</td></tr></tbody></table></div>
+<p>Benchmark numbers are machine-local telemetry. They are useful for catching regressions, not for promising a fixed throughput floor. Unsafe and unchecked numbers are not hostile-input equivalent to safe mode.</p>
+            </div>
+            <div class="locale-ko" lang="ko">
+<h2 id="engine-notes-ko-엔진-설계-노트">엔진 설계 노트</h2>
+<p>TypeSea는 TypeScript가 JavaScript를 emit한 뒤의 실행 특성을 예측 가능하게 만들기 위해 작성했습니다. 목표는 난해한 코드가 아닙니다. object shape, allocation site, branch behavior, validation contract가 코드에서 드러나도록 만드는 것이 목표입니다.</p>
+<h3 id="engine-notes-ko-hot-path-규칙">Hot Path 규칙</h3>
+<ul><li>per-instance method closure 대신 prototype method를 사용합니다.</li><li>schema, check, issue, IR node variant에는 numeric tag를 씁니다.</li><li>class field는 모든 constructor에서 같은 순서로 초기화합니다.</li><li>successful <code>is()</code> validation은 diagnostic allocation을 만들지 않습니다.</li><li><code>Issue</code> object와 path array는 diagnostic이 요청될 때만 할당합니다.</li><li>recursive validation path에서는 indexed loop를 선호합니다.</li><li>object-entry array는 schema construction 중 미리 계산합니다.</li><li>required object field가 data-property descriptor임을 증명한 뒤에는 missing-property fallback을 다시 검사하지 않고 descriptor value를 직접 읽습니다.</li><li>모든 field가 required인 strict object는 field validation 뒤 own string name과 own symbol 수를 세어 extra를 거부합니다. optional strict object는 전체 key membership scan을 유지합니다.</li><li><code>compile()</code>과 <code>emitAotModule()</code>은 safe가 기본입니다. unsafe mode는 명시적 opt-in이며, caller가 getter, prototype, symbol-extra risk를 받아들였을 때 direct property/index load와 own-enumerable strict-key loop를 쓸 수 있습니다.</li><li>constructed guard는 out-of-band로 표시합니다. 정상 receiver는 반복 schema validation을 피하고, forged receiver는 structural check로 fallback합니다.</li><li>object guard 뒤에는 <code>Readonly&lt;Record&lt;string, unknown&gt;&gt;</code>을 사용합니다.</li><li>generated-validator literal, regexp, keyset, dynamic fallback은 사용자가 제어하는 값을 source text에 interpolate하지 않고 side table에 저장합니다.</li></ul>
+<h3 id="engine-notes-ko-타입-시스템-규칙">타입 시스템 규칙</h3>
+<ul><li><code>optional(inner)</code>은 object key가 없어도 된다는 뜻입니다.</li><li><code>undefinedable(inner)</code>은 object shape에서 key가 반드시 존재하지만 value가 <code>undefined</code>일 수 있다는 뜻입니다.</li><li><code>nullable(inner)</code>은 value가 <code>null</code>일 수 있다는 뜻입니다.</li><li>presence-preserving wrapper는 optional-key semantics를 지우지 않습니다.</li><li><code>number</code>는 finite JavaScript number를 의미합니다.</li><li>신뢰할 수 없는 입력의 boundary type은 <code>unknown</code>만 허용합니다.</li><li>builder validation은 schema가 engine에 도달하기 전의 hard barrier입니다.</li></ul>
+<h3 id="engine-notes-ko-ir-규칙">IR 규칙</h3>
+<p>public schema tree는 builder와 diagnostic collector가 사용하는 semantic source입니다. boolean validation은 cached <code>ValidationPlan</code>을 실행합니다. schema identity는 Sea-of-Nodes IR로 낮아지고 optimizer를 거치며, plan은 frozen graph와 schema-specialized predicate kernel을 함께 보유합니다.</p>
+<p>graph는 장식이 아닙니다. <code>compile()</code>, AOT emission, <code>Guard.graph()</code>는 모두 plan이 보유한 optimized graph를 소비합니다. ordinary <code>Guard.is()</code>는 generic node interpreter 대신 sibling schema-specialized kernel을 의도적으로 사용합니다. 가장 흔한 hot path에서는 per-node dispatch와 scratch-slot bookkeeping 비용이 이득보다 크기 때문입니다.</p>
+<p>현재 lowering은 pure value node와 predicate node를 hash-cons합니다. strict object schema는 explicit keyset check를 IR로 낮춥니다. 따라서 extra-key rejection이 out-of-band schema knowledge에 의존하지 않습니다. required object field와 optional object field는 key presence와 data-property presence를 분리합니다. 이 방식은 accessor-backed property의 getter를 실행하거나 valid value로 잘못 분류하지 않게 합니다.</p>
+<p><code>Guard.graph()</code>는 validation plan이 보유한 동일한 optimized graph를 반환합니다. public graph value는 API 밖으로 나가기 전에 validate되고 freeze됩니다. 첫 optimizer pass는 reachable node elimination을 수행하고 node id를 compact해서 모든 dependency가 존재하는 dense node index를 가리키게 합니다. <code>compile()</code>과 AOT emission은 이 graph를 predicate source로 사용합니다.</p>
+<p>array, tuple, record schema는 native composite IR node로 낮아지며, child schema는 child validation plan을 통해 실행됩니다. <code>SchemaCheck</code>는 <code>lazy</code>와 <code>refine</code> 같은 dynamic schema에 예약되어 있습니다. graph는 callback 또는 resolver-backed semantics가 필요하다는 사실을 기록하며, 이것을 static predicate인 척하지 않습니다.</p>
+<h3 id="engine-notes-ko-runtime-compiler">Runtime Compiler</h3>
+<p>compiled guard는 optimized Sea-of-Nodes graph에서 boolean predicate를 방출하고, failed value용 schema-aware diagnostic collector를 함께 생성합니다. runtime <code>is()</code>는 plan-owned schema-specialized kernel을 사용해 recursive node dispatch와 scratch buffer churn을 피합니다. <code>check()</code>는 먼저 plan predicate로 pass/fail verdict를 얻습니다. successful value는 diagnostic collection을 건너뛰고, failed value는 diagnostic collector를 replay해서 path와 issue code를 만듭니다.</p>
+<p>user-controlled literal, regexp, object key, keyset, dynamic schema, diagnostic name은 generated factory가 capture한 side table에 둡니다. generated source에는 numeric side-table index, fixed helper string, sanitized function name만 들어갑니다.</p>
+<p>semantic이 local한 scalar node는 direct JavaScript test로 emit됩니다. finite-number check, integer check, string length bound, literal equality, regexp test는 generated hot path에서 helper call 없이 낮아집니다.</p>
+<p>array와 record IR node는 indexed loop를 emit합니다. static child schema는 optimized graph에서 해당 loop 안으로 inline됩니다. 작은 scalar 또는 union element contract에서 function-call boundary를 피하기 위해서입니다. tuple node는 descriptor-based element access를 보존하고, dynamic edge는 ordinary guard execution과 같은 IR-backed runtime fallback을 사용합니다. 따라서 <code>lazy</code>와 <code>refine</code>의 동작이 유지됩니다.</p>
+<p>strict object IR은 두 가지 shape으로 emit됩니다. 모든 declared key가 required이면 generated validator는 field descriptor read보다 먼저 strict-key count를 실행합니다. <code>Object.getOwnPropertyNames(value).length</code>를 declared key count와 비교하고, <code>Object.getOwnPropertySymbols(value).length === 0</code>을 요구합니다. V8은 generic <code>Reflect.ownKeys</code> count보다 이 count-only path를 더 잘 최적화하고, obvious extra-key object를 field descriptor를 만지기 전에 거부할 수 있습니다. optional strict object는 missing optional key를 final key count만으로 구분할 수 없으므로 full own-key membership scan을 emit합니다.</p>
+<p><code>compile(..., { mode: &quot;unsafe&quot; })</code>와 <code>emitAotModule(..., { mode: &quot;unsafe&quot; })</code>는 generated predicate를 trusted-data code shape으로 전환합니다. schema가 <code>undefined</code>를 거부하는 required object field는 descriptor 또는 own-key check 없이 direct <code>value[key]</code> load를 사용합니다. <code>undefined</code>를 허용할 수 있는 required field는 missing required key가 valid <code>undefined</code> value로 collapse되지 않도록 own-key presence guard를 유지합니다. optional field는 present non-<code>undefined</code> value에 direct-load fast path를 쓰고, ambiguous <code>undefined</code> case에서만 own-key check로 fallback합니다.</p>
+<p>unsafe array, tuple, record, discriminant path도 direct load를 선호합니다. strict object는 own-key array를 할당하는 대신 <code>for...in</code> own-enumerable key loop를 사용합니다. ASCII identifier object key는 <code>value.id</code> 같은 dot-property load로 emit되고, 나머지는 escaped string-literal bracket load로 emit됩니다. 이는 의도적으로 safe mode와 같은 적대적 입력 방어가 아닙니다. getter가 실행될 수 있고, prototype-backed value가 accepted될 수 있으며, symbol 또는 non-enumerable strict extra가 거부되지 않고, static property name이 unsafe generated predicate source에 나타날 수 있습니다.</p>
+<p><code>mode: &quot;unchecked&quot;</code>는 unsafe direct-read shape을 유지하면서 strict extra-key loop를 제거합니다. caller가 이미 정규화한 object를 위한 trusted-shape path입니다. 이 모드에서 strict object는 더 이상 extra key를 거부하지 않습니다.</p>
+<p>fast mode는 successful compiled <code>check()</code> result에서 <code>Object.freeze()</code>도 제거합니다. 반환 object는 동일한 <code>{ ok: true, value }</code> shape을 유지하지만 의도적으로 freeze되지 않습니다. failed diagnostic은 success hot path 밖에 있고 reporting을 위해 보존되는 일이 많으므로 계속 freeze됩니다. fast mode의 object diagnostic은 predicate와 같은 direct-read contract에서 생성됩니다. required field는 <code>value.key</code>로 읽고, optional field는 direct load 뒤 <code>undefined</code>일 때 own-key fallback을 사용하며, unsafe strict object는 own enumerable string key를 scan하고, unchecked strict object는 strict-key diagnostic scan을 건너뜁니다. fast mode의 array와 tuple diagnostic은 descriptor probe 대신 direct index로 item을 읽습니다. record diagnostic은 <code>record[key]</code>로 읽습니다. unchecked mode는 inherited enumerable key를 의도적으로 보이게 둡니다. discriminant diagnostic은 tag를 직접 읽고 literal string case를 strict equality로 비교합니다.</p>
+<h3 id="engine-notes-ko-재귀">재귀</h3>
+<p>lazy schema는 guard instance마다 getter를 한 번 resolve합니다. 따라서 recursive validation은 stable schema identity를 보고, 반복 validation이 recursive schema graph를 다시 만들지 않습니다.</p>
+<p>recursive validation은 root-local active pair table을 사용합니다. key는 runtime object identity와 schema identity의 pair입니다. 같은 schema/value pair에 다시 들어오면 그 edge를 short-circuit합니다. 이 방식으로 cyclic object graph도 유한하게 검증하면서, outer frame에서는 원래 object field를 계속 검사합니다.</p>
+<p>compiled <code>lazy</code>와 <code>refine</code> fallback은 같은 IR-backed runtime path를 사용하므로 recursive behavior가 execution engine 사이에서 일관됩니다.</p>
+<p><code>checkFirst()</code>는 별도의 generated collector를 사용합니다. 첫 diagnostic이 확정되는 즉시 frozen issue 하나를 반환하며, full <code>check()</code> collector를 끝까지 실행한 뒤 issue array를 자르지 않습니다.</p>
+<h3 id="engine-notes-ko-json-schema-export">JSON Schema Export</h3>
+<p>JSON Schema export는 TypeSea schema를 JSON-compatible input value 위에서 의미 손실 없이 표현할 수 있을 때만 성공합니다. runtime-only concept는 typed <code>Result</code> error를 반환합니다.</p>
+<p>export diagnostic은 모든 것을 parent container로 collapse하지 않고 failed child slot에 path를 유지합니다. 따라서 nested unsupported schema도 schema tree를 수동으로 재구성하지 않고 바로 조치할 수 있습니다.</p>
+<p>literal check는 runtime-plan과 compiled path 모두에서 <code>Object.is</code>를 사용합니다. diagnostic도 <code>-0</code>을 포함해 같은 literal formatting을 사용하므로 compiled와 runtime-plan <code>check()</code> result가 test에서 byte-for-byte로 비교됩니다.</p>
+<h3 id="engine-notes-ko-benchmark-범위">Benchmark 범위</h3>
+<p>benchmark suite는 두 질문을 분리합니다.</p>
+<ul><li><code>compile.bench.ts</code>는 같은 TypeSea schema를 대상으로 TypeSea runtime-plan validator와 compiled validator를 비교합니다.</li><li><code>ecosystem.bench.ts</code>는 하나의 JSON-compatible strict-object contract를 대상으로 TypeSea runtime-plan, TypeSea compiled, Zod, Valibot, Ajv를 비교합니다.</li></ul>
+<p>Zod, Valibot, Ajv는 측정용 dev dependency입니다. <code>src</code>에서 import하지 않으며, package policy는 release 전에 runtime, peer, optional, bundled dependency field를 거부합니다.</p>
+<p>2026-07-04 KST의 마지막 로컬 벤치마크는 JSON-compatible strict-object benchmark에서 아래 ecosystem path를 보고했습니다.</p>
+<div class="table-wrap"><table><thead><tr><th>Case</th><th>TypeSea runtime plan</th><th>TypeSea compiled safe</th><th>TypeSea compiled unsafe</th><th>TypeSea compiled unchecked</th><th>Ajv compiled</th></tr></thead><tbody><tr><td>Valid <code>is()</code></td><td>513,701 hz</td><td>4,297,306 hz</td><td>36,297,653 hz</td><td>42,581,174 hz</td><td>4,275,389 hz</td></tr>
+<tr><td>Valid <code>check()</code></td><td>503,232 hz</td><td>3,903,929 hz</td><td>35,568,425 hz</td><td>40,084,605 hz</td><td>4,278,587 hz</td></tr>
+<tr><td>Invalid <code>is()</code></td><td>3,636,369 hz</td><td>42,080,241 hz</td><td>49,654,076 hz</td><td>50,482,732 hz</td><td>27,820,643 hz</td></tr>
+<tr><td>Invalid <code>check()</code></td><td>420,446 hz</td><td>2,086,129 hz</td><td>3,077,367 hz</td><td>3,673,508 hz</td><td>28,713,035 hz</td></tr></tbody></table></div>
+<p>benchmark number는 machine-local telemetry입니다. regression을 잡는 데 유용하지만 고정된 throughput floor를 약속하지 않습니다. unsafe와 unchecked number는 safe mode와 hostile-input equivalent가 아닙니다.</p>
+            </div>
+          </article>
         </main>
       </div>
     </div>
-
-    <script>
-      const search = document.querySelector("[data-search]");
-      const sections = Array.from(document.querySelectorAll("[data-doc-section]"));
-      const links = Array.from(document.querySelectorAll(".nav a"));
-      const groups = Array.from(document.querySelectorAll(".nav-group"));
-
-      if (search instanceof HTMLInputElement) {
-        search.addEventListener("input", () => {
-          const query = search.value.trim().toLowerCase();
-          for (const section of sections) {
-            const title = section.getAttribute("data-title") ?? "";
-            const text = section.textContent?.toLowerCase() ?? "";
-            const visible = query === "" || title.includes(query) || text.includes(query);
-            section.classList.toggle("hidden", !visible);
-          }
-          for (const link of links) {
-            const target = link.getAttribute("href") ?? "";
-            const section = target.startsWith("#")
-              ? document.getElementById(target.slice(1))
-              : null;
-            const visible = section === null || !section.classList.contains("hidden");
-            link.classList.toggle("hidden", !visible);
-          }
-          for (const group of groups) {
-            let sibling = group.nextElementSibling;
-            let anyVisible = false;
-            while (sibling !== null && !sibling.classList.contains("nav-group")) {
-              if (sibling.matches("a") && !sibling.classList.contains("hidden")) {
-                anyVisible = true;
-              }
-              sibling = sibling.nextElementSibling;
-            }
-            group.classList.toggle("hidden", !anyVisible);
-          }
-        });
-      }
-
-      const linkById = new Map(
-        links
-          .map((link) => [link.getAttribute("href")?.slice(1) ?? "", link])
-          .filter(([id]) => id !== "")
-      );
-
-      if ("IntersectionObserver" in window) {
-        const observer = new IntersectionObserver(
-          (entries) => {
-            for (const entry of entries) {
-              if (entry.isIntersecting) {
-                for (const link of links) {
-                  link.classList.toggle(
-                    "active",
-                    link === linkById.get(entry.target.id)
-                  );
-                }
-              }
-            }
-          },
-          { rootMargin: "-20% 0px -70% 0px" }
-        );
-        for (const section of sections) {
-          observer.observe(section);
-        }
-      }
-    </script>
   </body>
 </html>