Switch to zod mini to reduce app size by 47 kB

```diff
dist/index.html 1.26 kB │ gzip: 0.61 kB
dist/assets/index-DqFAHrPz.css 28.97 kB │ gzip: 6.23 kB
- dist/assets/index-7NasAjCA.js 469 kB │ gzip: 153.07 kB
+ dist/assets/index-AU2GL5_c.js 422 kB │ gzip: 141.05 kB
```

Author: TrySound

src/dtcg.schema.ts

@@ -1,42 +1,41 @@
 // Zod schema based on Design Tokens Community Group specification
 // does not support JSON Pointer references
 
-import { z } from "zod";
+import * as z from "zod/mini";
 
 // token and group names MUST NOT:
 // - start with '$' (reserved prefix per DTCG spec)
 // - contain '{' (used in references syntax)
 // - contain '}' (used in references syntax)
 // - contain '.' (used in path separators within references)
-export const nameSchema = z
-  .string()
-  .refine(
+export const nameSchema = z.string().check(
+  z.refine(
     (name) => !name.startsWith("$"),
     "Token and group names must not start with '$'",
-  )
-  .refine(
+  ),
+  z.refine(
     (name) => !name.includes("{"),
     "Token and group names must not contain '{'",
-  )
-  .refine(
+  ),
+  z.refine(
     (name) => !name.includes("}"),
     "Token and group names must not contain '}'",
-  )
-  .refine(
+  ),
+  z.refine(
     (name) => !name.includes("."),
     "Token and group names must not contain '.'",
-  );
+  ),
+);
 
 // references use dot-separated paths with curly braces like {colors.primary}
 // each segment must be a valid name per nameSchema
 // special case: $root token is allowed within references as it uses the $ prefix
-export const referenceSchema = z
-  .string()
-  .refine(
+export const referenceSchema = z.string().check(
+  z.refine(
     (value) => value.startsWith("{") && value.endsWith("}"),
     "Reference must be enclosed in curly braces",
-  )
-  .refine((value) => {
+  ),
+  z.refine((value) => {
     const content = value.slice(1, -1);
     const segments = content.split(".");
     return (
@@ -47,7 +46,8 @@ export const referenceSchema = z
         return nameSchema.safeParse(segment).success;
       })
     );
-  }, "Each segment in reference must be a valid name");
+  }, "Each segment in reference must be a valid name"),
+);
 
 // Token types
 const tokenType = z.enum([
@@ -90,8 +90,8 @@ const colorSpace = z.enum([
 export const colorValue = z.object({
   colorSpace: colorSpace,
   components: z.array(colorComponent),
-  alpha: z.number().optional(),
-  hex: z.string().optional(),
+  alpha: z.optional(z.number()),
+  hex: z.optional(z.string()),
 });
 
 export const dimensionValue = z.object({
@@ -101,11 +101,11 @@ export const dimensionValue = z.object({
 
 export const fontFamilyValue = z.union([
   z.string(),
-  z.array(z.string()).min(1),
+  z.array(z.string()).check(z.minLength(1)),
 ]);
 
 export const fontWeightValue = z.union([
-  z.number().min(1).max(1000),
+  z.number().check(z.minimum(1), z.maximum(1000)),
   z.enum([
     "thin",
     "hairline",
@@ -156,7 +156,7 @@ export const strokeStyleString = z.enum([
 export const strokeStyleValue = z.union([
   strokeStyleString,
   z.object({
-    dashArray: z.array(dimensionValue).min(1),
+    dashArray: z.array(dimensionValue).check(z.minLength(1)),
     lineCap: z.enum(["round", "butt", "square"]),
   }),
 ]);
@@ -181,20 +181,20 @@ const shadowObject = z.object({
   offsetY: z.union([dimensionValue, referenceSchema]),
   blur: z.union([dimensionValue, referenceSchema]),
   spread: z.union([dimensionValue, referenceSchema]),
-  inset: z.boolean().optional(),
+  inset: z.optional(z.boolean()),
 });
 
 export const shadowValue = z.union([
   shadowObject,
-  z.array(shadowObject).min(1),
+  z.array(shadowObject).check(z.minLength(1)),
 ]);
 
 const gradientStop = z.object({
   color: z.union([colorValue, referenceSchema]),
   position: z.number(),
 });
 
-export const gradientValue = z.array(gradientStop).min(1);
+export const gradientValue = z.array(gradientStop).check(z.minLength(1));
 
 export const typographyValue = z.object({
   fontFamily: z.union([fontFamilyValue, referenceSchema]),
@@ -221,19 +221,19 @@ export const tokenSchema = z.object({
     typographyValue,
     referenceSchema,
   ]),
-  $type: tokenType.optional(),
-  $description: z.string().optional(),
-  $extensions: z.record(z.string(), z.unknown()).optional(),
-  $deprecated: z.union([z.boolean(), z.string()]).optional(),
+  $type: z.optional(tokenType),
+  $description: z.optional(z.string()),
+  $extensions: z.optional(z.record(z.string(), z.unknown())),
+  $deprecated: z.optional(z.union([z.boolean(), z.string()])),
 });
 
 export const groupSchema = z.object({
-  $type: tokenType.optional(),
-  $description: z.string().optional(),
-  $extensions: z.record(z.string(), z.unknown()).optional(),
-  $extends: referenceSchema.optional(),
-  $deprecated: z.union([z.boolean(), z.string()]).optional(),
-  $root: tokenSchema.optional(),
+  $type: z.optional(tokenType),
+  $description: z.optional(z.string()),
+  $extensions: z.optional(z.record(z.string(), z.unknown())),
+  $extends: z.optional(referenceSchema),
+  $deprecated: z.optional(z.union([z.boolean(), z.string()])),
+  $root: z.optional(tokenSchema),
 });
 
 export type Token = z.infer<typeof tokenSchema>;
@@ -262,7 +262,7 @@ export const resolverSourceSchema = z.record(
   z.string(),
   // avoid checking to not cut of nested groups and tokens
   // but enforce as a type
-  z.unknown() as z.ZodType<Token | Group>,
+  z.unknown() as z.ZodMiniType<Token | Group>,
 );
 
 export type ResolverSource = z.infer<typeof resolverSourceSchema>;
@@ -272,8 +272,8 @@ export const resolverSetSchema = z.object({
   type: z.literal("set"),
   name: nameSchema, // required, unique identifier within resolutionOrder
   sources: z.array(resolverSourceSchema), // non-optional, can be empty
-  description: z.string().optional(),
-  $extensions: z.record(z.string(), z.unknown()).optional(),
+  description: z.optional(z.string()),
+  $extensions: z.optional(z.record(z.string(), z.unknown())),
 });
 
 export type ResolverSet = z.infer<typeof resolverSetSchema>;
@@ -289,9 +289,9 @@ export const resolverModifierSchema = z.object({
   type: z.literal("modifier"),
   name: nameSchema, // required, unique identifier within resolutionOrder
   contexts: resolverModifierContextsSchema, // non-optional
-  description: z.string().optional(),
-  default: z.string().optional(),
-  $extensions: z.record(z.string(), z.unknown()).optional(),
+  description: z.optional(z.string()),
+  default: z.optional(z.string()),
+  $extensions: z.optional(z.record(z.string(), z.unknown())),
 });
 
 export type ResolverModifier = z.infer<typeof resolverModifierSchema>;
@@ -306,16 +306,16 @@ export type ResolutionOrderItem = z.infer<typeof resolutionOrderItemSchema>;
 
 // Unsupported root-level sets and modifiers
 // These reject any object with properties - only allow undefined or empty object
-const unsupportedSetsSchema = z.object({}).strict().optional();
-const unsupportedModifiersSchema = z.object({}).strict().optional();
+const unsupportedSetsSchema = z.optional(z.strictObject({}));
+const unsupportedModifiersSchema = z.optional(z.strictObject({}));
 
 // Resolver document following Design Tokens Resolver Module 2025.10
 export const resolverDocumentSchema = z.object({
   version: z.literal("2025.10"),
-  name: z.string().optional(),
-  description: z.string().optional(),
-  sets: unsupportedSetsSchema.optional(),
-  modifiers: unsupportedModifiersSchema.optional(),
+  name: z.optional(z.string()),
+  description: z.optional(z.string()),
+  sets: z.optional(unsupportedSetsSchema),
+  modifiers: z.optional(unsupportedModifiersSchema),
   resolutionOrder: z.array(resolutionOrderItemSchema),
 });
 

src/legacy.schema.ts

@@ -2,7 +2,7 @@
 // Supports dual-format parsing: legacy 2022 format and 2025 standard format
 // Output is always normalized to 2025 standard format
 
-import { z } from "zod";
+import * as z from "zod/mini";
 import { parseColor } from "./color";
 import {
   cubicBezierValue,
@@ -32,10 +32,9 @@ const expandShorthandHex = (hex: string): string => {
 // #rrggbb or #rrggbbaa or #rgb or #rgba
 const legacyColorRegex =
   /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/i;
-const legacyColorValue = z
-  .string()
-  .regex(legacyColorRegex)
-  .transform((value): ColorValue => {
+const legacyColorValue = z.pipe(
+  z.string().check(z.regex(legacyColorRegex)),
+  z.transform((value): ColorValue => {
     const expanded = expandShorthandHex(value.toLowerCase());
     // Extract alpha from last 2 chars if present
     let alphaHex = "ff";
@@ -55,14 +54,14 @@ const legacyColorValue = z
       delete colorValue.hex;
     }
     return colorValue;
-  });
+  }),
+);
 
 // "10px", "0.5rem", "-8px", "-0.5rem"
 const dimensionRegex = /^(-?\d+(?:\.\d+)?)(px|rem)$/;
-const legacyDimensionValue = z
-  .string()
-  .regex(dimensionRegex)
-  .transform((value): DimensionValue => {
+const legacyDimensionValue = z.pipe(
+  z.string().check(z.regex(dimensionRegex)),
+  z.transform((value): DimensionValue => {
     const match = value.match(dimensionRegex);
     if (!match) {
       throw new Error(`Invalid dimension: ${value}`);
@@ -71,14 +70,14 @@ const legacyDimensionValue = z
       value: Number.parseFloat(match[1]),
       unit: match[2] as "px" | "rem",
     };
-  });
+  }),
+);
 
 // "200ms", "1.5s", "-100ms", "-0.5s"
 const durationRegex = /^(-?\d+(?:\.\d+)?)(ms|s)$/;
-const legacyDurationValue = z
-  .string()
-  .regex(durationRegex)
-  .transform((value): DurationValue => {
+const legacyDurationValue = z.pipe(
+  z.string().check(z.regex(durationRegex)),
+  z.transform((value): DurationValue => {
     const match = value.match(durationRegex);
     if (!match) {
       throw new Error(`Invalid duration: ${value}`);
@@ -87,31 +86,32 @@ const legacyDurationValue = z
       value: Number.parseFloat(match[1]),
       unit: match[2] as "ms" | "s",
     };
-  });
+  }),
+);
 
 // "200", "1.5", "-42", "-3.14"
 const numberRegex = /^(-?\d+(?:\.\d+)?)$/;
-const legacyNumberValue = z
-  .string()
-  .regex(numberRegex)
-  .transform((value): number => {
+const legacyNumberValue = z.pipe(
+  z.string().check(z.regex(numberRegex)),
+  z.transform((value): number => {
     const match = value.match(numberRegex);
     if (!match) {
       throw new Error(`Invalid number: ${value}`);
     }
     return Number.parseFloat(match[1]);
-  });
+  }),
+);
 
 const legacyStrokeStyleValue = z.union([
   strokeStyleString,
   z.object({
-    dashArray: z.array(legacyDimensionValue).min(1),
+    dashArray: z.array(legacyDimensionValue).check(z.minLength(1)),
     lineCap: z.enum(["round", "butt", "square"]),
   }),
 ]);
 
 const legacyShadowObject = z.object({
-  inset: z.boolean().optional(),
+  inset: z.optional(z.boolean()),
   color: z.union([legacyColorValue, referenceSchema]),
   offsetX: z.union([legacyDimensionValue, referenceSchema]),
   offsetY: z.union([legacyDimensionValue, referenceSchema]),
@@ -140,7 +140,7 @@ const legacyGradientStop = z.object({
   color: z.union([legacyColorValue, referenceSchema]),
   position: z.number(),
 });
-const legacyGradientValue = z.array(legacyGradientStop).min(1);
+const legacyGradientValue = z.array(legacyGradientStop).check(z.minLength(1));
 
 const legacyTypographyValue = z.object({
   fontFamily: z.union([fontFamilyValue, referenceSchema]),
@@ -150,7 +150,7 @@ const legacyTypographyValue = z.object({
   lineHeight: z.union([legacyNumberValue, referenceSchema]),
 });
 
-export const legacyTokenSchema = tokenSchema.extend({
+export const legacyTokenSchema = z.extend(tokenSchema, {
   $value: z.union([
     legacyColorValue,
     legacyDimensionValue,

src/resolver.test.ts

@@ -70,7 +70,7 @@ describe("parseTokenResolver", () => {
       resolutionOrder: [],
     });
     expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].message).toContain("2025.10");
+    expect(result.errors[0].message).toContain("version");
   });
 
   test("rejects root-level sets object with property keys", () => {

src/resolver.ts

@@ -1,4 +1,4 @@
-import { prettifyError } from "zod";
+import * as z from "zod/mini";
 import { generateKeyBetween } from "fractional-indexing";
 import {
   resolverDocumentSchema,
@@ -88,7 +88,7 @@ export const parseTokenResolver = (input: unknown): ParseResult => {
   const validation = resolverDocumentSchema.safeParse(input);
 
   if (!validation.success) {
-    const errorMessage = prettifyError(validation.error);
+    const errorMessage = z.prettifyError(validation.error);
     return {
       nodes: [],
       errors: [{ path: "resolver", message: errorMessage }],

src/schema.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod/mini";
 import {
   colorValue,
   cubicBezierValue,
@@ -94,7 +94,7 @@ const shadowItemSchema = z.object({
   offsetY: dimensionValue,
   blur: dimensionValue,
   spread: dimensionValue,
-  inset: z.boolean().optional(),
+  inset: z.optional(z.boolean()),
 });
 
 const shadowSchema = z.object({
@@ -108,7 +108,7 @@ const rawShadowItemSchema = z.object({
   offsetY: z.union([dimensionValue, nodeRefSchema]),
   blur: z.union([dimensionValue, nodeRefSchema]),
   spread: z.union([dimensionValue, nodeRefSchema]),
-  inset: z.boolean().optional(),
+  inset: z.optional(z.boolean()),
 });
 
 const rawShadowSchema = z.object({

src/state.svelte.ts

@@ -1,4 +1,4 @@
-import { formatError } from "zod";
+import * as z from "zod/mini";
 import { createSubscriber } from "svelte/reactivity";
 import { TreeStore, type Transaction, type TreeNode } from "./store";
 import {
@@ -123,7 +123,7 @@ export const resolveRawValue = (
     const resolvedValue = resolveRawValue(tokenNode, nodes, newStack);
     const parsed = RawValueSchema.safeParse(resolvedValue);
     if (!parsed.success) {
-      throw Error(formatError(parsed.error)._errors.join("\n"));
+      throw Error(z.formatError(parsed.error)._errors.join("\n"));
     }
     return resolvedValue;
   }