typesea 0.1.0 → 0.2.0

package/dist/schema/validate.js

@@ -1,12 +1,19 @@
 /**
  * @file schema/validate.ts
  * @brief Runtime validators for direct schema objects.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
  */
 import { NumberCheckTag, ObjectModeTag, PresenceTag, SchemaTag, StringCheckTag } from "../kind/index.js";
 import { isLiteralValue } from "./literal.js";
-import { includesString, isObjectKeyLookup, isPlainRegExp, isRecord, isStringArray, isUnknownArray } from "./common.js";
+import { includesString, isMissingDataProperty, isObjectKeyLookup, isPlainRegExp, isRecord, isStringArray, isUnknownArray, readOwnDataProperty } from "./common.js";
 /**
- * @brief is schema value.
+ * @brief Validate an unknown value as a TypeSea schema tree.
+ * @param value Candidate schema object from a public boundary.
+ * @returns True when the complete tree satisfies the internal schema layout.
+ * @details This routine is intentionally stricter than normal JavaScript object
+ * access: every record and vector must be data-only so later consumers can read
+ * fields without invoking user code.
  */
 export function isSchemaValue(value) {
     return isSchemaValueInner(value, {
@@ -15,7 +22,12 @@ export function isSchemaValue(value) {
     });
 }
 /**
- * @brief is schema value inner.
+ * @brief Validate one schema node with cycle protection.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate node.
+ * @param state Recursion state shared by the root validation pass.
+ * @returns True when this node and its reachable children are well-formed.
  */
 function isSchemaValueInner(value, state) {
     if (!isRecord(value)) {
@@ -28,6 +40,10 @@ function isSchemaValueInner(value, state) {
         return false;
     }
     state.visiting.add(value);
+    /*
+     * The node is placed in `visiting` before child traversal so recursive
+     * object graphs fail closed instead of creating an infinite walk.
+     */
     const valid = isSchemaRecord(value, state);
     state.visiting.delete(value);
     if (valid) {
@@ -36,10 +52,17 @@ function isSchemaValueInner(value, state) {
     return valid;
 }
 /**
- * @brief is schema record.
+ * @brief Dispatch validation by schema tag.
+ * @param value Data-only record already accepted by isRecord.
+ * @param state Recursion state for child schemas.
+ * @returns True when the tag-specific payload is well-formed.
+ * @details Tag and payload fields are read through readOwnDataProperty. This
+ * preserves the rule that forged schema prototypes never participate in schema
+ * admission.
  */
 function isSchemaRecord(value, state) {
-    switch (value["tag"]) {
+    const tag = readOwnDataProperty(value, "tag");
+    switch (tag) {
         case SchemaTag.Unknown:
         case SchemaTag.Never:
         case SchemaTag.BigInt:
@@ -47,45 +70,55 @@ function isSchemaRecord(value, state) {
         case SchemaTag.Boolean:
             return true;
         case SchemaTag.String:
-            return isStringChecks(value["checks"]);
+            return isStringChecks(readOwnDataProperty(value, "checks"));
         case SchemaTag.Number:
-            return isNumberChecks(value["checks"]);
-        case SchemaTag.Literal:
-            return isLiteralValue(value["value"]);
+            return isNumberChecks(readOwnDataProperty(value, "checks"));
+        case SchemaTag.Literal: {
+            const literal = readOwnDataProperty(value, "value");
+            /*
+             * `undefined` is a legal literal payload. The sentinel distinguishes
+             * a missing `value` field from a stored undefined literal.
+             */
+            return !isMissingDataProperty(literal) && isLiteralValue(literal);
+        }
         case SchemaTag.Array:
-            return isSchemaValueInner(value["item"], state);
+            return isSchemaValueInner(readOwnDataProperty(value, "item"), state);
         case SchemaTag.Tuple:
-            return isSchemaArray(value["items"], state);
+            return isSchemaArray(readOwnDataProperty(value, "items"), state);
         case SchemaTag.Record:
-            return isSchemaValueInner(value["value"], state);
+            return isSchemaValueInner(readOwnDataProperty(value, "value"), state);
         case SchemaTag.Object:
             return isObjectSchemaValue(value, state);
         case SchemaTag.Union:
-            return isSchemaArray(value["options"], state);
+            return isSchemaArray(readOwnDataProperty(value, "options"), state);
         case SchemaTag.Intersection:
-            return isSchemaValueInner(value["left"], state) &&
-                isSchemaValueInner(value["right"], state);
+            return isSchemaValueInner(readOwnDataProperty(value, "left"), state) &&
+                isSchemaValueInner(readOwnDataProperty(value, "right"), state);
         case SchemaTag.Optional:
         case SchemaTag.Undefinedable:
         case SchemaTag.Nullable:
-            return isSchemaValueInner(value["inner"], state);
+            return isSchemaValueInner(readOwnDataProperty(value, "inner"), state);
         case SchemaTag.DiscriminatedUnion:
             return isDiscriminatedUnionSchemaValue(value, state);
         case SchemaTag.Brand:
-            return typeof value["brand"] === "string" &&
-                isSchemaValueInner(value["inner"], state);
+            return typeof readOwnDataProperty(value, "brand") === "string" &&
+                isSchemaValueInner(readOwnDataProperty(value, "inner"), state);
         case SchemaTag.Lazy:
-            return typeof value["get"] === "function";
+            return typeof readOwnDataProperty(value, "get") === "function";
         case SchemaTag.Refine:
-            return typeof value["name"] === "string" &&
-                typeof value["predicate"] === "function" &&
-                isSchemaValueInner(value["inner"], state);
+            return typeof readOwnDataProperty(value, "name") === "string" &&
+                typeof readOwnDataProperty(value, "predicate") === "function" &&
+                isSchemaValueInner(readOwnDataProperty(value, "inner"), state);
         default:
             return false;
     }
 }
 /**
- * @brief is string checks.
+ * @brief Validate the check vector attached to a string schema.
+ * @param value Candidate check vector.
+ * @returns True when every check is data-only and semantically usable.
+ * @details Bounds are constrained at admission so interpreter and codegen do not
+ * need to repeat defensive numeric checks in their hot paths.
  */
 function isStringChecks(value) {
     if (!isUnknownArray(value)) {
@@ -96,17 +129,22 @@ function isStringChecks(value) {
         if (!isRecord(check)) {
             return false;
         }
-        switch (check["tag"]) {
+        switch (readOwnDataProperty(check, "tag")) {
             case StringCheckTag.Min:
             case StringCheckTag.Max: {
-                const bound = check["value"];
+                const bound = readOwnDataProperty(check, "value");
                 if (typeof bound !== "number" || !Number.isInteger(bound) || bound < 0) {
                     return false;
                 }
                 break;
             }
             case StringCheckTag.Regex:
-                if (!isPlainRegExp(check["regex"]) || typeof check["name"] !== "string") {
+                /*
+                 * Regex checks carry executable engine state. Only a plain
+                 * RegExp plus a stable diagnostic name can enter the schema.
+                 */
+                if (!isPlainRegExp(readOwnDataProperty(check, "regex")) ||
+                    typeof readOwnDataProperty(check, "name") !== "string") {
                     return false;
                 }
                 break;
@@ -119,7 +157,11 @@ function isStringChecks(value) {
     return true;
 }
 /**
- * @brief is number checks.
+ * @brief Validate the check vector attached to a number schema.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate check vector.
+ * @returns True when all numeric bounds are finite and tag-compatible.
  */
 function isNumberChecks(value) {
     if (!isUnknownArray(value)) {
@@ -130,12 +172,12 @@ function isNumberChecks(value) {
         if (!isRecord(check)) {
             return false;
         }
-        switch (check["tag"]) {
+        switch (readOwnDataProperty(check, "tag")) {
             case NumberCheckTag.Integer:
                 break;
             case NumberCheckTag.Gte:
             case NumberCheckTag.Lte: {
-                const bound = check["value"];
+                const bound = readOwnDataProperty(check, "value");
                 if (typeof bound !== "number" || !Number.isFinite(bound)) {
                     return false;
                 }
@@ -148,7 +190,12 @@ function isNumberChecks(value) {
     return true;
 }
 /**
- * @brief is schema array.
+ * @brief Validate a dense vector of child schemas.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param value Candidate schema vector.
+ * @param state Recursion state shared with the parent node.
+ * @returns True when every vector slot is a valid schema.
  */
 function isSchemaArray(value, state) {
     if (!isUnknownArray(value)) {
@@ -162,16 +209,23 @@ function isSchemaArray(value, state) {
     return true;
 }
 /**
- * @brief is object schema value.
+ * @brief Validate object-schema payload invariants.
+ * @param value Candidate object schema record.
+ * @param state Recursion state for property schemas.
+ * @returns True when entries, key order, lookup, and presence metadata agree.
+ * @details Object validation depends on three redundant views: ordered entries
+ * for stable codegen, ordered keys for strict key checks, and lookup for fast
+ * membership. Admission rejects drift between those views.
  */
 function isObjectSchemaValue(value, state) {
-    if (value["mode"] !== ObjectModeTag.Passthrough &&
-        value["mode"] !== ObjectModeTag.Strict) {
+    const mode = readOwnDataProperty(value, "mode");
+    if (mode !== ObjectModeTag.Passthrough &&
+        mode !== ObjectModeTag.Strict) {
         return false;
     }
-    const entries = value["entries"];
-    const keys = value["keys"];
-    const keyLookup = value["keyLookup"];
+    const entries = readOwnDataProperty(value, "entries");
+    const keys = readOwnDataProperty(value, "keys");
+    const keyLookup = readOwnDataProperty(value, "keyLookup");
     if (!isUnknownArray(entries) || !isStringArray(keys) ||
         !isObjectKeyLookup(keyLookup, keys) || entries.length !== keys.length) {
         return false;
@@ -179,43 +233,70 @@ function isObjectSchemaValue(value, state) {
     const seen = [];
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        if (!isRecord(entry) ||
-            typeof entry["key"] !== "string" ||
-            entry["key"] !== keys[index] ||
-            includesString(seen, entry["key"]) ||
-            (entry["presence"] !== PresenceTag.Required &&
-                entry["presence"] !== PresenceTag.Optional) ||
-            !isSchemaValueInner(entry["schema"], state)) {
+        if (!isRecord(entry)) {
+            return false;
+        }
+        const key = readOwnDataProperty(entry, "key");
+        const presence = readOwnDataProperty(entry, "presence");
+        const schema = readOwnDataProperty(entry, "schema");
+        /*
+         * The entry key must match the parallel `keys` slot. That keeps emitted
+         * object code deterministic and prevents a lookup table from describing
+         * a different shape than the property graph.
+         */
+        if (typeof key !== "string" ||
+            key !== keys[index] ||
+            includesString(seen, key) ||
+            (presence !== PresenceTag.Required &&
+                presence !== PresenceTag.Optional) ||
+            !isSchemaValueInner(schema, state)) {
             return false;
         }
-        seen.push(entry["key"]);
+        seen.push(key);
     }
     return true;
 }
 /**
- * @brief is discriminated union schema value.
+ * @brief Validate discriminated-union dispatch metadata.
+ * @param value Candidate discriminated union record.
+ * @param state Recursion state for case schemas.
+ * @returns True when each case owns a unique literal and proves the tag field.
+ * @details The case schema must require the discriminant literal. Without that
+ * proof, dispatch could choose a branch before the branch actually validates the
+ * same discriminant field.
  */
 function isDiscriminatedUnionSchemaValue(value, state) {
-    const cases = value["cases"];
-    const key = value["key"];
+    const cases = readOwnDataProperty(value, "cases");
+    const key = readOwnDataProperty(value, "key");
     if (typeof key !== "string" || !isUnknownArray(cases) || cases.length === 0) {
         return false;
     }
     const literals = [];
     for (let index = 0; index < cases.length; index += 1) {
         const unionCase = cases[index];
-        if (!isRecord(unionCase) || typeof unionCase["literal"] !== "string" ||
-            includesString(literals, unionCase["literal"]) ||
-            !isSchemaValueInner(unionCase["schema"], state) ||
-            !caseRequiresDiscriminant(unionCase["schema"], key, unionCase["literal"])) {
+        if (!isRecord(unionCase)) {
+            return false;
+        }
+        const literal = readOwnDataProperty(unionCase, "literal");
+        const schema = readOwnDataProperty(unionCase, "schema");
+        if (typeof literal !== "string" ||
+            includesString(literals, literal) ||
+            !isSchemaValueInner(schema, state) ||
+            !caseRequiresDiscriminant(schema, key, literal)) {
             return false;
         }
-        literals.push(unionCase["literal"]);
+        literals.push(literal);
     }
     return true;
 }
 /**
- * @brief case requires discriminant.
+ * @brief Prove that one case schema requires the requested discriminant value.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param schema Case schema after structural validation.
+ * @param key Discriminant property name.
+ * @param literal Required literal value for this case.
+ * @returns True when an object case contains a required matching literal field.
  */
 function caseRequiresDiscriminant(schema, key, literal) {
     const objectSchema = unwrapCaseObjectSchema(schema);
@@ -234,7 +315,12 @@ function caseRequiresDiscriminant(schema, key, literal) {
     return false;
 }
 /**
- * @brief unwrap case object schema.
+ * @brief Peel transparent wrappers until an object case schema is reached.
+ * @param schema Case schema.
+ * @returns The object schema used for discriminant proof, or undefined.
+ * @details Intersections and transparent wrappers can carry the object branch
+ * while still adding extra validation. Lazy and union nodes are not unwrapped
+ * here because they do not give a local, branch-stable object proof.
  */
 function unwrapCaseObjectSchema(schema) {
     switch (schema.tag) {
@@ -250,7 +336,12 @@ function unwrapCaseObjectSchema(schema) {
     }
 }
 /**
- * @brief schema requires literal.
+ * @brief Check whether a schema forces one exact string literal.
+ * @details Schema helpers enforce construction-time invariants before values reach
+ * validation, compilation, or export.
+ * @param schema Property schema.
+ * @param literal Required literal value.
+ * @returns True when the schema cannot accept a different discriminant value.
  */
 function schemaRequiresLiteral(schema, literal) {
     switch (schema.tag) {

package/docs/api.md

@@ -187,10 +187,67 @@ 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.
 
+### Unsafe Compile Mode
+
+```ts
+const FastButLooseUser = compile(User, {
+  name: "isUserFast",
+  mode: "unsafe"
+});
+```
+
+`CompileOptions["mode"]` and `AotCompileOptions["mode"]` are
+`"safe" | "unsafe" | "unchecked" | undefined`; omitted options default to
+`"safe"`. 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.
+
+Unsafe mode is an explicit performance escape hatch for trusted, normalized
+plain data:
+
+- Required object fields read with `value[key]` when the field schema rejects
+  `undefined`.
+- Discriminant dispatch reads the tag with direct bracket access.
+- Arrays and tuples read items with direct indexed loads.
+- Strict-object extra-key rejection uses an allocation-free own-enumerable
+  `for...in` loop.
+
+This may execute getters, may accept prototype-backed values, and does not
+reject symbol or non-enumerable extras on strict objects. Because compiled
+`check()` first trusts the generated predicate verdict, an unsafe predicate
+that returns `true` also returns a successful `check()` result. Use unsafe mode
+only after the input has crossed a trusted normalization boundary.
+
+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.
+
+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 `check()` calls also return raw successful Result
+objects without `Object.freeze()`. 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 `undefined` value. Record diagnostics use direct `record[key]` reads;
+unchecked mode also visits inherited enumerable keys. Discriminant diagnostics
+read the tag directly and compare string cases with `===`.
+
 ## AOT Emit
 
 ```ts
 const emitted = emitAotModule(User, { name: "aotUser" });
+const unsafeEmitted = emitAotModule(User, {
+  name: "aotUserFast",
+  mode: "unsafe"
+});
+const uncheckedEmitted = emitAotModule(User, {
+  name: "aotUserTrustedShape",
+  mode: "unchecked"
+});
 ```
 
 `emitAotModule` returns `Result<AotModule, AotIssue[]>`. A successful result

package/docs/assets/benchmark-headline.svg

@@ -0,0 +1,163 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1120" height="760" viewBox="0 0 1120 760" role="img" aria-labelledby="title desc">
+    <title id="title">TypeSea benchmark comparison</title>
+    <desc id="desc">Local strict object benchmark comparing TypeSea safe, unsafe, unchecked, Zod, Valibot, and Ajv throughput.</desc>
+    <defs>
+        <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
+            <stop offset="0" stop-color="#071014"/>
+            <stop offset="0.58" stop-color="#0f172a"/>
+            <stop offset="1" stop-color="#13251f"/>
+        </linearGradient>
+        <linearGradient id="panel" x1="0" y1="0" x2="1" y2="1">
+            <stop offset="0" stop-color="#111827"/>
+            <stop offset="1" stop-color="#0b1220"/>
+        </linearGradient>
+        <linearGradient id="safe" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#14b8a6"/>
+            <stop offset="1" stop-color="#2dd4bf"/>
+        </linearGradient>
+        <linearGradient id="unsafe" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#f97316"/>
+            <stop offset="1" stop-color="#fbbf24"/>
+        </linearGradient>
+        <linearGradient id="unchecked" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#22c55e"/>
+            <stop offset="1" stop-color="#a3e635"/>
+        </linearGradient>
+        <linearGradient id="ajv" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#3b82f6"/>
+            <stop offset="1" stop-color="#93c5fd"/>
+        </linearGradient>
+        <linearGradient id="zod" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#8b5cf6"/>
+            <stop offset="1" stop-color="#c4b5fd"/>
+        </linearGradient>
+        <linearGradient id="valibot" x1="0" y1="0" x2="1" y2="0">
+            <stop offset="0" stop-color="#ec4899"/>
+            <stop offset="1" stop-color="#f9a8d4"/>
+        </linearGradient>
+        <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
+            <feDropShadow dx="0" dy="14" stdDeviation="18" flood-color="#000000" flood-opacity="0.35"/>
+        </filter>
+        <style>
+            text { font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+            .title { fill: #f8fafc; font-size: 42px; font-weight: 800; letter-spacing: 0; }
+            .subtitle { fill: #94a3b8; font-size: 16px; font-weight: 500; }
+            .card-title { fill: #e5e7eb; font-size: 18px; font-weight: 800; }
+            .card-note { fill: #94a3b8; font-size: 12px; font-weight: 600; }
+            .metric-label { fill: #94a3b8; font-size: 12px; font-weight: 700; text-transform: uppercase; }
+            .metric-value { fill: #f8fafc; font-size: 30px; font-weight: 900; }
+            .metric-sub { fill: #cbd5e1; font-size: 13px; font-weight: 600; }
+            .bar-label { fill: #cbd5e1; font-size: 13px; font-weight: 700; }
+            .bar-value { fill: #f8fafc; font-size: 13px; font-weight: 800; }
+            .axis { stroke: #334155; stroke-width: 1; }
+        </style>
+    </defs>
+
+    <rect width="1120" height="760" rx="28" fill="url(#bg)"/>
+    <circle cx="1028" cy="82" r="180" fill="#22c55e" opacity="0.08"/>
+    <circle cx="84" cy="690" r="220" fill="#38bdf8" opacity="0.07"/>
+
+    <text id="headline" x="44" y="58" class="title">TypeSea benchmark comparison</text>
+    <text x="46" y="88" class="subtitle">Local run on 2026-07-04 KST, strict-object contract, ops/sec. Higher is better.</text>
+
+    <g filter="url(#shadow)">
+        <rect x="44" y="118" width="322" height="108" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="66" y="148" class="metric-label">Unchecked valid hot path</text>
+        <text x="66" y="188" class="metric-value">42.58M</text>
+        <text x="66" y="210" class="metric-sub">31.7x Zod, 10.0x Ajv</text>
+
+        <rect x="399" y="118" width="322" height="108" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="421" y="148" class="metric-label">Safe invalid fast-fail</text>
+        <text x="421" y="188" class="metric-value">42.08M</text>
+        <text x="421" y="210" class="metric-sub">1.51x Ajv, 499x Zod</text>
+
+        <rect x="754" y="118" width="322" height="108" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="776" y="148" class="metric-label">Safe valid path</text>
+        <text x="776" y="188" class="metric-value">4.30M</text>
+        <text x="776" y="210" class="metric-sub">Ajv-class while staying safe</text>
+    </g>
+
+    <g filter="url(#shadow)">
+        <rect x="44" y="260" width="1032" height="136" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="66" y="291" class="card-title">Valid object path</text>
+        <text x="230" y="291" class="card-note">linear scale to 42.58M</text>
+        <line x1="270" y1="318" x2="1010" y2="318" class="axis"/>
+
+        <text x="66" y="326" class="bar-label">TypeSea unchecked</text>
+        <rect x="270" y="312" width="740" height="15" rx="7.5" fill="url(#unchecked)"/>
+        <text x="1024" y="326" class="bar-value">42.58M</text>
+
+        <text x="66" y="350" class="bar-label">TypeSea unsafe</text>
+        <rect x="270" y="336" width="631" height="15" rx="7.5" fill="url(#unsafe)"/>
+        <text x="915" y="350" class="bar-value">36.30M</text>
+
+        <text x="66" y="374" class="bar-label">TypeSea safe / Ajv / Zod</text>
+        <rect x="270" y="360" width="75" height="15" rx="7.5" fill="url(#safe)"/>
+        <rect x="354" y="360" width="74" height="15" rx="7.5" fill="url(#ajv)"/>
+        <rect x="437" y="360" width="24" height="15" rx="7.5" fill="url(#valibot)"/>
+        <rect x="470" y="360" width="23" height="15" rx="7.5" fill="url(#zod)"/>
+        <text x="506" y="374" class="bar-value">safe 4.30M, Ajv 4.28M, Valibot 1.41M, Zod 1.34M</text>
+    </g>
+
+    <g filter="url(#shadow)">
+        <rect x="44" y="418" width="1032" height="150" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="66" y="449" class="card-title">Invalid object fast-fail</text>
+        <text x="268" y="449" class="card-note">linear scale to 50.48M</text>
+        <line x1="270" y1="476" x2="1010" y2="476" class="axis"/>
+
+        <text x="66" y="482" class="bar-label">TypeSea unchecked</text>
+        <rect x="270" y="468" width="740" height="15" rx="7.5" fill="url(#unchecked)"/>
+        <text x="1024" y="482" class="bar-value">50.48M</text>
+
+        <text x="66" y="506" class="bar-label">TypeSea unsafe</text>
+        <rect x="270" y="492" width="728" height="15" rx="7.5" fill="url(#unsafe)"/>
+        <text x="1024" y="506" class="bar-value">49.65M</text>
+
+        <text x="66" y="530" class="bar-label">TypeSea safe</text>
+        <rect x="270" y="516" width="617" height="15" rx="7.5" fill="url(#safe)"/>
+        <text x="902" y="530" class="bar-value">42.08M</text>
+
+        <text x="66" y="554" class="bar-label">Ajv / Valibot / Zod</text>
+        <rect x="270" y="540" width="408" height="15" rx="7.5" fill="url(#ajv)"/>
+        <rect x="690" y="540" width="13" height="15" rx="7.5" fill="url(#valibot)"/>
+        <rect x="714" y="540" width="3" height="15" rx="1.5" fill="url(#zod)"/>
+        <text x="734" y="554" class="bar-value">Ajv 27.82M, Valibot 0.88M, Zod 0.08M</text>
+    </g>
+
+    <g filter="url(#shadow)">
+        <rect x="44" y="576" width="1032" height="136" rx="18" fill="url(#panel)" stroke="#1f2937"/>
+        <text x="66" y="607" class="card-title">Invalid diagnostic path</text>
+        <text x="270" y="607" class="card-note">linear scale to 28.71M; Ajv is a boolean baseline</text>
+        <line x1="270" y1="634" x2="1010" y2="634" class="axis"/>
+
+        <text x="66" y="642" class="bar-label">Ajv compiled</text>
+        <rect x="270" y="628" width="740" height="15" rx="7.5" fill="url(#ajv)"/>
+        <text x="1024" y="642" class="bar-value">28.71M</text>
+
+        <text x="66" y="666" class="bar-label">TypeSea modes</text>
+        <rect x="270" y="652" width="95" height="15" rx="7.5" fill="url(#unchecked)"/>
+        <rect x="374" y="652" width="79" height="15" rx="7.5" fill="url(#unsafe)"/>
+        <rect x="462" y="652" width="54" height="15" rx="7.5" fill="url(#safe)"/>
+        <text x="532" y="666" class="bar-value">unchecked 3.67M, unsafe 3.08M, safe 2.09M</text>
+
+        <text x="66" y="690" class="bar-label">Valibot / Zod</text>
+        <rect x="270" y="676" width="23" height="15" rx="7.5" fill="url(#valibot)"/>
+        <rect x="302" y="676" width="3" height="15" rx="1.5" fill="url(#zod)"/>
+        <text x="322" y="690" class="bar-value">Valibot 0.89M, Zod 0.08M</text>
+    </g>
+
+    <g transform="translate(44 730)">
+        <rect x="0" y="-11" width="13" height="13" rx="3" fill="url(#safe)"/>
+        <text x="20" y="0" class="card-note">TypeSea safe</text>
+        <rect x="128" y="-11" width="13" height="13" rx="3" fill="url(#unsafe)"/>
+        <text x="148" y="0" class="card-note">unsafe</text>
+        <rect x="228" y="-11" width="13" height="13" rx="3" fill="url(#unchecked)"/>
+        <text x="248" y="0" class="card-note">unchecked</text>
+        <rect x="356" y="-11" width="13" height="13" rx="3" fill="url(#ajv)"/>
+        <text x="376" y="0" class="card-note">Ajv</text>
+        <rect x="426" y="-11" width="13" height="13" rx="3" fill="url(#valibot)"/>
+        <text x="446" y="0" class="card-note">Valibot</text>
+        <rect x="536" y="-11" width="13" height="13" rx="3" fill="url(#zod)"/>
+        <text x="556" y="0" class="card-note">Zod</text>
+    </g>
+</svg>