@svadmin/surface 0.4.6 → 0.6.0

package/README.md

@@ -7,7 +7,7 @@ The MVP supports Svelte 5 + Vite, a fixed 12-column grid, four built-in widgets,
 ## Install
 
 ```bash
-bun add @svadmin/surface @svadmin/core @svadmin/ui @tanstack/svelte-query svelte zod
+bun add @svadmin/surface @svadmin/core @svadmin/ui @tanstack/svelte-query svelte @sinclair/typebox
 ```
 
 Import protocol types and validation from the DOM-free root entry. Import rendering code from the Svelte subpath.
@@ -89,7 +89,7 @@ When rendered inside `AdminApp`, the renderer resolves the configured provider f
 
 The catalog version is `svadmin/v1`. `catalogVersion` must match exactly.
 
-Custom catalogs are trusted runtime configuration. Every registration must use a strict Zod v4 object schema and a trusted Svelte component. Item widgets that read record fields must expose those fields through `getReferencedFields`; validation then checks them against `SurfacePolicy.readFields`.
+Custom catalogs are trusted runtime configuration. Every registration must use a strict TypeBox object schema and a trusted Svelte component. Item widgets that read record fields must expose those fields through `getReferencedFields`; validation then checks them against `SurfacePolicy.readFields`.
 
 ```ts
 const catalog = defineSurfaceCatalog({

package/compatibility.json

@@ -1,5 +1,5 @@
 {
-  "surface": "0.4.x",
+  "surface": "0.6.x",
   "minimumSupported": {
     "@svadmin/core": "0.34.2",
     "@svadmin/ui": "0.40.6",

package/dist/builtin-schemas.d.ts

@@ -1,42 +1,172 @@
-import { z } from 'zod';
-export declare const metricPropsSchema: z.ZodObject<{
-    label: z.ZodString;
-    format: z.ZodEnum<{
-        number: "number";
-        currency: "currency";
-        percent: "percent";
-    }>;
-    currency: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const resourceTablePropsSchema: z.ZodObject<{
-    title: z.ZodString;
-    emptyLabel: z.ZodOptional<z.ZodString>;
-    columns: z.ZodArray<z.ZodObject<{
-        field: z.ZodString;
-        label: z.ZodString;
-        format: z.ZodOptional<z.ZodEnum<{
-            number: "number";
-            boolean: "boolean";
-            text: "text";
-            date: "date";
-        }>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const barChartPropsSchema: z.ZodObject<{
-    title: z.ZodString;
-    labelField: z.ZodString;
-    valueField: z.ZodString;
-    showValues: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const lineChartPropsSchema: z.ZodObject<{
-    title: z.ZodString;
-    labelField: z.ZodString;
-    valueField: z.ZodString;
-    showDots: z.ZodOptional<z.ZodBoolean>;
-    fill: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type MetricProps = z.infer<typeof metricPropsSchema>;
-export type ResourceTableProps = z.infer<typeof resourceTablePropsSchema>;
-export type BarChartProps = z.infer<typeof barChartPropsSchema>;
-export type LineChartProps = z.infer<typeof lineChartPropsSchema>;
+import { type Static, type TSchema } from "@sinclair/typebox";
+export declare function createParsedSchema<T extends TSchema>(schema: T): T & {
+    parse: (value: unknown) => Static<T>;
+    safeParse: (value: unknown) => {
+        success: true;
+        data: Static<T>;
+    } | {
+        success: false;
+        error: {
+            issues: Array<{
+                path: string[];
+                message: string;
+            }>;
+        };
+    };
+    Check: (value: unknown) => boolean;
+};
+export declare const metricPropsSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    format: import("@sinclair/typebox").TLiteral<"currency">;
+    currency: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    format: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"number">, import("@sinclair/typebox").TLiteral<"percent">]>;
+    currency: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNever>;
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>]> & {
+    parse: (value: unknown) => {
+        description?: string | undefined;
+        currency: string;
+        label: string;
+        format: "currency";
+    } | {
+        description?: string | undefined;
+        currency?: undefined;
+        label: string;
+        format: "number" | "percent";
+    };
+    safeParse: (value: unknown) => {
+        success: false;
+        error: {
+            issues: Array<{
+                path: string[];
+                message: string;
+            }>;
+        };
+    } | {
+        success: true;
+        data: {
+            description?: string | undefined;
+            currency: string;
+            label: string;
+            format: "currency";
+        } | {
+            description?: string | undefined;
+            currency?: undefined;
+            label: string;
+            format: "number" | "percent";
+        };
+    };
+    Check: (value: unknown) => boolean;
+};
+export declare const resourceTablePropsSchema: import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TString;
+    emptyLabel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    columns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        field: import("@sinclair/typebox").TString;
+        label: import("@sinclair/typebox").TString;
+        format: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"text">, import("@sinclair/typebox").TLiteral<"number">, import("@sinclair/typebox").TLiteral<"date">, import("@sinclair/typebox").TLiteral<"boolean">]>>;
+    }>>;
+}> & {
+    parse: (value: unknown) => {
+        emptyLabel?: string | undefined;
+        title: string;
+        columns: {
+            format?: "number" | "boolean" | "text" | "date" | undefined;
+            field: string;
+            label: string;
+        }[];
+    };
+    safeParse: (value: unknown) => {
+        success: false;
+        error: {
+            issues: Array<{
+                path: string[];
+                message: string;
+            }>;
+        };
+    } | {
+        success: true;
+        data: {
+            emptyLabel?: string | undefined;
+            title: string;
+            columns: {
+                format?: "number" | "boolean" | "text" | "date" | undefined;
+                field: string;
+                label: string;
+            }[];
+        };
+    };
+    Check: (value: unknown) => boolean;
+};
+export declare const barChartPropsSchema: import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TString;
+    labelField: import("@sinclair/typebox").TString;
+    valueField: import("@sinclair/typebox").TString;
+    showValues: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}> & {
+    parse: (value: unknown) => {
+        showValues?: boolean | undefined;
+        title: string;
+        labelField: string;
+        valueField: string;
+    };
+    safeParse: (value: unknown) => {
+        success: false;
+        error: {
+            issues: Array<{
+                path: string[];
+                message: string;
+            }>;
+        };
+    } | {
+        success: true;
+        data: {
+            showValues?: boolean | undefined;
+            title: string;
+            labelField: string;
+            valueField: string;
+        };
+    };
+    Check: (value: unknown) => boolean;
+};
+export declare const lineChartPropsSchema: import("@sinclair/typebox").TObject<{
+    title: import("@sinclair/typebox").TString;
+    labelField: import("@sinclair/typebox").TString;
+    valueField: import("@sinclair/typebox").TString;
+    showDots: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    fill: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}> & {
+    parse: (value: unknown) => {
+        fill?: boolean | undefined;
+        showDots?: boolean | undefined;
+        title: string;
+        labelField: string;
+        valueField: string;
+    };
+    safeParse: (value: unknown) => {
+        success: false;
+        error: {
+            issues: Array<{
+                path: string[];
+                message: string;
+            }>;
+        };
+    } | {
+        success: true;
+        data: {
+            fill?: boolean | undefined;
+            showDots?: boolean | undefined;
+            title: string;
+            labelField: string;
+            valueField: string;
+        };
+    };
+    Check: (value: unknown) => boolean;
+};
+export type MetricProps = Static<typeof metricPropsSchema>;
+export type ResourceTableProps = Static<typeof resourceTablePropsSchema>;
+export type BarChartProps = Static<typeof barChartPropsSchema>;
+export type LineChartProps = Static<typeof lineChartPropsSchema>;

package/dist/builtin-schemas.js

@@ -1,37 +1,82 @@
-import { z } from 'zod';
-const catalogFieldSchema = z.string().min(1).max(64).regex(/^[A-Za-z][A-Za-z0-9_-]*$/u);
-export const metricPropsSchema = z.object({
-    label: z.string().min(1).max(80),
-    format: z.enum(['number', 'currency', 'percent']),
-    currency: z.string().regex(/^[A-Z]{3}$/u).optional(),
-    description: z.string().min(1).max(160).optional(),
-}).strict().superRefine((props, context) => {
-    if (props.format === 'currency' && !props.currency) {
-        context.addIssue({ code: 'custom', path: ['currency'], message: 'Currency format requires an ISO currency code' });
-    }
-    if (props.format !== 'currency' && props.currency) {
-        context.addIssue({ code: 'custom', path: ['currency'], message: 'Currency is only valid with currency format' });
-    }
+import { Type } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+export function createParsedSchema(schema) {
+    const compiled = TypeCompiler.Compile(schema);
+    const parse = (value) => {
+        if (compiled.Check(value))
+            return value;
+        const errors = [...compiled.Errors(value)];
+        const message = errors.map((e) => (e.path ? e.path + ": " : "") + e.message).join(", ") || "Validation error";
+        const err = new Error(message);
+        err.issues = errors.map((e) => ({
+            path: e.path ? (e.path.startsWith("/") ? e.path.slice(1) : e.path).split("/") : [],
+            message: e.message,
+        }));
+        throw err;
+    };
+    const safeParse = (value) => {
+        if (compiled.Check(value)) {
+            return { success: true, data: value };
+        }
+        const errors = [...compiled.Errors(value)];
+        return {
+            success: false,
+            error: {
+                issues: errors.map((e) => ({
+                    path: e.path ? (e.path.startsWith("/") ? e.path.slice(1) : e.path).split("/") : [],
+                    message: e.message,
+                })),
+            },
+        };
+    };
+    return Object.assign(schema, {
+        parse,
+        safeParse,
+        Check: (val) => compiled.Check(val),
+    });
+}
+const catalogFieldSchema = Type.String({
+    minLength: 1,
+    maxLength: 64,
+    pattern: "^[A-Za-z][A-Za-z0-9_-]*$",
 });
-export const resourceTablePropsSchema = z.object({
-    title: z.string().min(1).max(80),
-    emptyLabel: z.string().min(1).max(80).optional(),
-    columns: z.array(z.object({
+const currencyMetric = Type.Object({
+    label: Type.String({ minLength: 1, maxLength: 80 }),
+    format: Type.Literal("currency"),
+    currency: Type.String({ pattern: "^[A-Z]{3}$" }),
+    description: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
+}, { additionalProperties: false });
+const otherMetric = Type.Object({
+    label: Type.String({ minLength: 1, maxLength: 80 }),
+    format: Type.Union([Type.Literal("number"), Type.Literal("percent")]),
+    currency: Type.Optional(Type.Never()),
+    description: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
+}, { additionalProperties: false });
+export const metricPropsSchema = createParsedSchema(Type.Union([currencyMetric, otherMetric]));
+export const resourceTablePropsSchema = createParsedSchema(Type.Object({
+    title: Type.String({ minLength: 1, maxLength: 80 }),
+    emptyLabel: Type.Optional(Type.String({ minLength: 1, maxLength: 80 })),
+    columns: Type.Array(Type.Object({
         field: catalogFieldSchema,
-        label: z.string().min(1).max(60),
-        format: z.enum(['text', 'number', 'date', 'boolean']).optional(),
-    }).strict()).min(1).max(8),
-}).strict();
-export const barChartPropsSchema = z.object({
-    title: z.string().min(1).max(80),
+        label: Type.String({ minLength: 1, maxLength: 60 }),
+        format: Type.Optional(Type.Union([
+            Type.Literal("text"),
+            Type.Literal("number"),
+            Type.Literal("date"),
+            Type.Literal("boolean"),
+        ])),
+    }, { additionalProperties: false }), { minItems: 1, maxItems: 8 }),
+}, { additionalProperties: false }));
+export const barChartPropsSchema = createParsedSchema(Type.Object({
+    title: Type.String({ minLength: 1, maxLength: 80 }),
     labelField: catalogFieldSchema,
     valueField: catalogFieldSchema,
-    showValues: z.boolean().optional(),
-}).strict();
-export const lineChartPropsSchema = z.object({
-    title: z.string().min(1).max(80),
+    showValues: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false }));
+export const lineChartPropsSchema = createParsedSchema(Type.Object({
+    title: Type.String({ minLength: 1, maxLength: 80 }),
     labelField: catalogFieldSchema,
     valueField: catalogFieldSchema,
-    showDots: z.boolean().optional(),
-    fill: z.boolean().optional(),
-}).strict();
+    showDots: Type.Optional(Type.Boolean()),
+    fill: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false }));

package/dist/catalog.d.ts

@@ -21,57 +21,171 @@ export declare const defaultSurfaceCatalog: {
     readonly widgets: readonly [{
         readonly type: "metric";
         readonly dataKind: "scalar";
-        readonly propsSchema: import("zod").ZodObject<{
-            label: import("zod").ZodString;
-            format: import("zod").ZodEnum<{
-                number: "number";
-                currency: "currency";
-                percent: "percent";
-            }>;
-            currency: import("zod").ZodOptional<import("zod").ZodString>;
-            description: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strict>;
+        readonly propsSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+            label: import("@sinclair/typebox").TString;
+            format: import("@sinclair/typebox").TLiteral<"currency">;
+            currency: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>, import("@sinclair/typebox").TObject<{
+            label: import("@sinclair/typebox").TString;
+            format: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"number">, import("@sinclair/typebox").TLiteral<"percent">]>;
+            currency: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNever>;
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>]> & {
+            parse: (value: unknown) => {
+                description?: string | undefined;
+                currency: string;
+                label: string;
+                format: "currency";
+            } | {
+                description?: string | undefined;
+                currency?: undefined;
+                label: string;
+                format: "number" | "percent";
+            };
+            safeParse: (value: unknown) => {
+                success: false;
+                error: {
+                    issues: Array<{
+                        path: string[];
+                        message: string;
+                    }>;
+                };
+            } | {
+                success: true;
+                data: {
+                    description?: string | undefined;
+                    currency: string;
+                    label: string;
+                    format: "currency";
+                } | {
+                    description?: string | undefined;
+                    currency?: undefined;
+                    label: string;
+                    format: "number" | "percent";
+                };
+            };
+            Check: (value: unknown) => boolean;
+        };
         readonly component: Component<SurfaceWidgetRendererProps, {}, "">;
     }, {
         readonly type: "resource-table";
         readonly dataKind: "items";
-        readonly propsSchema: import("zod").ZodObject<{
-            title: import("zod").ZodString;
-            emptyLabel: import("zod").ZodOptional<import("zod").ZodString>;
-            columns: import("zod").ZodArray<import("zod").ZodObject<{
-                field: import("zod").ZodString;
-                label: import("zod").ZodString;
-                format: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    number: "number";
-                    boolean: "boolean";
-                    text: "text";
-                    date: "date";
-                }>>;
-            }, import("zod/v4/core").$strict>>;
-        }, import("zod/v4/core").$strict>;
+        readonly propsSchema: import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            emptyLabel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            columns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                field: import("@sinclair/typebox").TString;
+                label: import("@sinclair/typebox").TString;
+                format: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"text">, import("@sinclair/typebox").TLiteral<"number">, import("@sinclair/typebox").TLiteral<"date">, import("@sinclair/typebox").TLiteral<"boolean">]>>;
+            }>>;
+        }> & {
+            parse: (value: unknown) => {
+                emptyLabel?: string | undefined;
+                title: string;
+                columns: {
+                    format?: "number" | "boolean" | "text" | "date" | undefined;
+                    field: string;
+                    label: string;
+                }[];
+            };
+            safeParse: (value: unknown) => {
+                success: false;
+                error: {
+                    issues: Array<{
+                        path: string[];
+                        message: string;
+                    }>;
+                };
+            } | {
+                success: true;
+                data: {
+                    emptyLabel?: string | undefined;
+                    title: string;
+                    columns: {
+                        format?: "number" | "boolean" | "text" | "date" | undefined;
+                        field: string;
+                        label: string;
+                    }[];
+                };
+            };
+            Check: (value: unknown) => boolean;
+        };
         readonly getReferencedFields: typeof tableFields;
         readonly component: Component<SurfaceWidgetRendererProps, {}, "">;
     }, {
         readonly type: "bar-chart";
         readonly dataKind: "items";
-        readonly propsSchema: import("zod").ZodObject<{
-            title: import("zod").ZodString;
-            labelField: import("zod").ZodString;
-            valueField: import("zod").ZodString;
-            showValues: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strict>;
+        readonly propsSchema: import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            labelField: import("@sinclair/typebox").TString;
+            valueField: import("@sinclair/typebox").TString;
+            showValues: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        }> & {
+            parse: (value: unknown) => {
+                showValues?: boolean | undefined;
+                title: string;
+                labelField: string;
+                valueField: string;
+            };
+            safeParse: (value: unknown) => {
+                success: false;
+                error: {
+                    issues: Array<{
+                        path: string[];
+                        message: string;
+                    }>;
+                };
+            } | {
+                success: true;
+                data: {
+                    showValues?: boolean | undefined;
+                    title: string;
+                    labelField: string;
+                    valueField: string;
+                };
+            };
+            Check: (value: unknown) => boolean;
+        };
         readonly getReferencedFields: typeof barChartFields;
         readonly component: Component<SurfaceWidgetRendererProps, {}, "">;
     }, {
         readonly type: "line-chart";
         readonly dataKind: "items";
-        readonly propsSchema: import("zod").ZodObject<{
-            title: import("zod").ZodString;
-            labelField: import("zod").ZodString;
-            valueField: import("zod").ZodString;
-            showDots: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            fill: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        }, import("zod/v4/core").$strict>;
+        readonly propsSchema: import("@sinclair/typebox").TObject<{
+            title: import("@sinclair/typebox").TString;
+            labelField: import("@sinclair/typebox").TString;
+            valueField: import("@sinclair/typebox").TString;
+            showDots: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            fill: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        }> & {
+            parse: (value: unknown) => {
+                fill?: boolean | undefined;
+                showDots?: boolean | undefined;
+                title: string;
+                labelField: string;
+                valueField: string;
+            };
+            safeParse: (value: unknown) => {
+                success: false;
+                error: {
+                    issues: Array<{
+                        path: string[];
+                        message: string;
+                    }>;
+                };
+            } | {
+                success: true;
+                data: {
+                    fill?: boolean | undefined;
+                    showDots?: boolean | undefined;
+                    title: string;
+                    labelField: string;
+                    valueField: string;
+                };
+            };
+            Check: (value: unknown) => boolean;
+        };
         readonly getReferencedFields: typeof lineChartFields;
         readonly component: Component<SurfaceWidgetRendererProps, {}, "">;
     }];

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { DataProvider } from '@svadmin/core';
-import type { ZodType } from 'zod';
+import type { TSchema } from '@sinclair/typebox';
 export declare const SURFACE_SCHEMA_VERSION: "surface/v1";
 export declare const SURFACE_LIMITS: {
     readonly maxDataSources: 8;
@@ -92,7 +92,12 @@ export type SurfaceCatalogDataKind = 'none' | 'scalar' | 'items';
 export interface SurfaceWidgetDefinition {
     readonly type: string;
     readonly dataKind: SurfaceCatalogDataKind;
-    readonly propsSchema: ZodType<unknown>;
+    readonly propsSchema: TSchema | {
+        Check?: (data: unknown) => boolean;
+        safeParse?: (data: unknown) => {
+            success: boolean;
+        };
+    };
     /** 组件从绑定记录中读取的字段，由可信 Catalog 提供。 */
     readonly getReferencedFields?: (props: JsonObject) => readonly string[];
 }

package/dist/validation.d.ts

@@ -1,2 +1,2 @@
-import { type SurfaceCatalog, type SurfacePolicy, type SurfaceValidationResult } from './types.js';
+import { type SurfaceCatalog, type SurfacePolicy, type SurfaceValidationResult } from "./types.js";
 export declare function validateSurfaceSpec(input: unknown, catalog: SurfaceCatalog, policy: SurfacePolicy): SurfaceValidationResult;

package/dist/validation.js

@@ -1,75 +1,126 @@
-import { z } from 'zod';
-import { decodedJsonPointerToken, jsonPointer, jsonValueIssue } from './json.js';
-import { SURFACE_LIMITS, SURFACE_SCHEMA_VERSION, } from './types.js';
-const idSchema = z.string().min(1).max(SURFACE_LIMITS.maxIdLength).regex(/^[A-Za-z][A-Za-z0-9_-]*$/u);
-const fieldSchema = z.string().min(1).max(SURFACE_LIMITS.maxIdLength);
-const jsonPrimitiveSchema = z.union([z.string(), z.number().finite(), z.boolean(), z.null()]);
-const surfaceFilterSchema = z.discriminatedUnion('operator', [
-    z.object({
+import { Type } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+import { Value } from "@sinclair/typebox/value";
+import { decodedJsonPointerToken, jsonPointer, jsonValueIssue } from "./json.js";
+import { SURFACE_LIMITS, SURFACE_SCHEMA_VERSION, } from "./types.js";
+const idSchema = Type.String({
+    minLength: 1,
+    maxLength: SURFACE_LIMITS.maxIdLength,
+    pattern: "^[A-Za-z][A-Za-z0-9_-]*$",
+});
+const fieldSchema = Type.String({
+    minLength: 1,
+    maxLength: SURFACE_LIMITS.maxIdLength,
+});
+const jsonPrimitiveSchema = Type.Union([
+    Type.String(),
+    Type.Number(),
+    Type.Boolean(),
+    Type.Null(),
+]);
+const surfaceFilterSchema = Type.Union([
+    Type.Object({
         field: fieldSchema,
-        operator: z.enum(['eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'contains', 'startswith', 'endswith']),
+        operator: Type.Union([
+            Type.Literal("eq"),
+            Type.Literal("ne"),
+            Type.Literal("lt"),
+            Type.Literal("lte"),
+            Type.Literal("gt"),
+            Type.Literal("gte"),
+            Type.Literal("contains"),
+            Type.Literal("startswith"),
+            Type.Literal("endswith"),
+        ]),
         value: jsonPrimitiveSchema,
-    }).strict(),
-    z.object({
+    }, { additionalProperties: false }),
+    Type.Object({
         field: fieldSchema,
-        operator: z.enum(['in', 'nin']),
-        value: z.array(jsonPrimitiveSchema),
-    }).strict(),
-    z.object({
+        operator: Type.Union([
+            Type.Literal("in"),
+            Type.Literal("nin"),
+        ]),
+        value: Type.Array(jsonPrimitiveSchema),
+    }, { additionalProperties: false }),
+    Type.Object({
         field: fieldSchema,
-        operator: z.enum(['null', 'nnull']),
-    }).strict(),
+        operator: Type.Union([
+            Type.Literal("null"),
+            Type.Literal("nnull"),
+        ]),
+    }, { additionalProperties: false }),
 ]);
-const resourceListSchema = z.object({
+const resourceListSchema = Type.Object({
     id: idSchema,
-    type: z.literal('resource-list'),
+    type: Type.Literal("resource-list"),
     resource: idSchema,
-    pageSize: z.number().int().positive().optional(),
-    sorters: z.array(z.object({ field: fieldSchema, order: z.enum(['asc', 'desc']) }).strict()).optional(),
-    filters: z.array(surfaceFilterSchema).optional(),
-}).strict();
-const resourceOneSchema = z.object({
+    pageSize: Type.Optional(Type.Integer({ minimum: 1 })),
+    sorters: Type.Optional(Type.Array(Type.Object({
+        field: fieldSchema,
+        order: Type.Union([Type.Literal("asc"), Type.Literal("desc")]),
+    }, { additionalProperties: false }))),
+    filters: Type.Optional(Type.Array(surfaceFilterSchema)),
+}, { additionalProperties: false });
+const resourceOneSchema = Type.Object({
     id: idSchema,
-    type: z.literal('resource-one'),
+    type: Type.Literal("resource-one"),
     resource: idSchema,
-    recordId: z.union([z.string(), z.number().finite()]),
-}).strict();
-const surfaceSpecSchema = z.object({
-    schemaVersion: z.string(),
-    catalogVersion: z.string().min(1),
+    recordId: Type.Union([Type.String(), Type.Number()]),
+}, { additionalProperties: false });
+const surfaceSpecSchema = Type.Object({
+    schemaVersion: Type.String(),
+    catalogVersion: Type.String({ minLength: 1 }),
     surfaceId: idSchema,
-    title: z.string().min(1).max(SURFACE_LIMITS.maxTitleLength),
-    layout: z.object({
-        type: z.literal('grid'),
-        columns: z.literal(12),
-        gap: z.enum(['sm', 'md', 'lg']).optional(),
-    }).strict(),
-    dataSources: z.array(z.discriminatedUnion('type', [resourceListSchema, resourceOneSchema])),
-    widgets: z.array(z.object({
+    title: Type.String({ minLength: 1, maxLength: SURFACE_LIMITS.maxTitleLength }),
+    layout: Type.Object({
+        type: Type.Literal("grid"),
+        columns: Type.Literal(12),
+        gap: Type.Optional(Type.Union([
+            Type.Literal("sm"),
+            Type.Literal("md"),
+            Type.Literal("lg"),
+        ])),
+    }, { additionalProperties: false }),
+    dataSources: Type.Array(Type.Union([resourceListSchema, resourceOneSchema])),
+    widgets: Type.Array(Type.Object({
         id: idSchema,
         type: idSchema,
-        props: z.record(z.string(), z.unknown()),
-        binding: z.object({ sourceId: idSchema, pointer: z.string().optional() }).strict().optional(),
-        placement: z.object({ columnSpan: z.number().int().min(1).max(12).optional() }).strict().optional(),
-    }).strict()),
-}).strict();
+        props: Type.Record(Type.String(), Type.Unknown()),
+        binding: Type.Optional(Type.Object({
+            sourceId: idSchema,
+            pointer: Type.Optional(Type.String()),
+        }, { additionalProperties: false })),
+        placement: Type.Optional(Type.Object({
+            columnSpan: Type.Optional(Type.Integer({ minimum: 1, maximum: 12 })),
+        }, { additionalProperties: false })),
+    }, { additionalProperties: false })),
+}, { additionalProperties: false });
+const compiledSurfaceSpec = TypeCompiler.Compile(surfaceSpecSchema);
 const forbiddenPropertyNames = new Set([
-    'class',
-    'className',
-    'color',
-    'href',
-    'html',
-    'innerHTML',
-    'src',
-    'style',
-    'url',
+    "class",
+    "className",
+    "color",
+    "href",
+    "html",
+    "innerHTML",
+    "src",
+    "style",
+    "url",
 ]);
-const strictSchemaProbeKey = '__surface_unknown_property_probe__';
+const strictSchemaProbeKey = "__surface_unknown_property_probe__";
 function invalidJsonIssue(pathSegments, message) {
-    return { code: 'invalid_json', path: jsonPointer(pathSegments), message };
+    return { code: "invalid_json", path: jsonPointer(pathSegments), message };
 }
-function schemaIssues(error) {
-    return error.issues.map((issue) => invalidJsonIssue(issue.path.map((segment) => typeof segment === 'symbol' ? String(segment) : segment), issue.message));
+function schemaErrors(errors) {
+    const issues = [];
+    for (const err of errors) {
+        issues.push({
+            code: "invalid_json",
+            path: err.path || "",
+            message: err.message,
+        });
+    }
+    return issues;
 }
 function catalogDefinitions(catalog) {
     return new Map(catalog.widgets.map((widgetDefinition) => [widgetDefinition.type, widgetDefinition]));
@@ -81,25 +132,25 @@ function sourcePolicyIssue(source, policy, index) {
     const resourcePolicy = resourcePolicyFor(policy, source.resource);
     if (!resourcePolicy) {
         return {
-            code: 'resource_denied',
+            code: "resource_denied",
             path: `/dataSources/${index}/resource`,
             message: `Resource "${source.resource}" is not allowed`,
             sourceId: source.id,
         };
     }
-    if (source.type === 'resource-one' && resourcePolicy.allowGetOne !== true) {
+    if (source.type === "resource-one" && resourcePolicy.allowGetOne !== true) {
         return {
-            code: 'resource_denied',
+            code: "resource_denied",
             path: `/dataSources/${index}`,
             message: `Resource "${source.resource}" does not allow getOne`,
             sourceId: source.id,
         };
     }
-    if (source.type === 'resource-list') {
+    if (source.type === "resource-list") {
         const pageSizeLimit = Math.min(resourcePolicy.maxPageSize ?? SURFACE_LIMITS.maxPageSize, SURFACE_LIMITS.maxPageSize);
         if ((source.pageSize ?? 10) > pageSizeLimit) {
             return {
-                code: 'limit_exceeded',
+                code: "limit_exceeded",
                 path: `/dataSources/${index}/pageSize`,
                 message: `Page size exceeds ${pageSizeLimit}`,
                 sourceId: source.id,
@@ -108,7 +159,7 @@ function sourcePolicyIssue(source, policy, index) {
         const disallowedSorter = source.sorters?.find((sorter) => !resourcePolicy.sortFields?.includes(sorter.field));
         if (disallowedSorter) {
             return {
-                code: 'field_denied',
+                code: "field_denied",
                 path: `/dataSources/${index}/sorters`,
                 message: `Sorting by "${disallowedSorter.field}" is not allowed`,
                 sourceId: source.id,
@@ -117,7 +168,7 @@ function sourcePolicyIssue(source, policy, index) {
         const disallowedFilter = source.filters?.find((filter) => !resourcePolicy.filterFields?.includes(filter.field));
         if (disallowedFilter) {
             return {
-                code: 'field_denied',
+                code: "field_denied",
                 path: `/dataSources/${index}/filters`,
                 message: `Filtering by "${disallowedFilter.field}" is not allowed`,
                 sourceId: source.id,
@@ -130,14 +181,14 @@ function propsContainForbiddenKey(props) {
     const pending = [props];
     while (pending.length > 0) {
         const current = pending.pop();
-        if (current === undefined || current === null || typeof current !== 'object')
+        if (current === undefined || current === null || typeof current !== "object")
             continue;
         if (Array.isArray(current)) {
             pending.push(...current);
             continue;
         }
         for (const [key, entry] of Object.entries(current)) {
-            if (forbiddenPropertyNames.has(key) || key.startsWith('on'))
+            if (forbiddenPropertyNames.has(key) || key.startsWith("on"))
                 return key;
             pending.push(entry);
         }
@@ -153,18 +204,18 @@ function referencedFieldIssue(widget, widgetIndex, definition, source, policy) {
     }
     catch {
         return {
-            code: 'invalid_widget_props',
+            code: "invalid_widget_props",
             path: `/widgets/${widgetIndex}/props`,
-            message: 'Widget field references could not be resolved',
+            message: "Widget field references could not be resolved",
             widgetId: widget.id,
         };
     }
     const readableFields = resourcePolicyFor(policy, source.resource)?.readFields ?? [];
-    const deniedField = referencedFields.find((field) => (typeof field !== 'string' || !readableFields.includes(field)));
+    const deniedField = referencedFields.find((field) => (typeof field !== "string" || !readableFields.includes(field)));
     return deniedField === undefined
         ? null
         : {
-            code: 'field_denied',
+            code: "field_denied",
             path: `/widgets/${widgetIndex}/props`,
             message: `Field "${String(deniedField)}" is not readable`,
             widgetId: widget.id,
@@ -172,44 +223,55 @@ function referencedFieldIssue(widget, widgetIndex, definition, source, policy) {
         };
 }
 function resourceOnePointerField(pointer) {
-    if (!pointer.startsWith('/') || pointer.slice(1).includes('/'))
+    if (!pointer.startsWith("/") || pointer.slice(1).includes("/"))
         return null;
     const field = decodedJsonPointerToken(pointer.slice(1));
     return field && field.length <= SURFACE_LIMITS.maxIdLength ? field : null;
 }
+function checkPropsSchema(schema, data) {
+    if (!schema || typeof schema !== "object")
+        return false;
+    if ("Check" in schema && typeof schema.Check === "function") {
+        return schema.Check(data);
+    }
+    if ("safeParse" in schema && typeof schema.safeParse === "function") {
+        return schema.safeParse(data).success;
+    }
+    return Value.Check(schema, data);
+}
 function widgetIssue(widget, widgetIndex, definition, sources, policy) {
     if (!definition) {
         return {
-            code: 'unknown_widget_type',
+            code: "unknown_widget_type",
             path: `/widgets/${widgetIndex}/type`,
             message: `Widget type "${widget.type}" is not registered`,
             widgetId: widget.id,
         };
     }
     const forbiddenKey = propsContainForbiddenKey(widget.props);
-    const propsValidation = definition.propsSchema.safeParse(widget.props);
-    const strictSchemaProbe = definition.propsSchema.safeParse({
+    const propsValid = checkPropsSchema(definition.propsSchema, widget.props);
+    const strictSchemaProbe = checkPropsSchema(definition.propsSchema, {
         ...widget.props,
         [strictSchemaProbeKey]: null,
     });
-    if (forbiddenKey || !propsValidation.success || strictSchemaProbe.success) {
+    if (forbiddenKey || !propsValid || strictSchemaProbe) {
         return {
-            code: 'invalid_widget_props',
+            code: "invalid_widget_props",
             path: `/widgets/${widgetIndex}/props`,
             message: forbiddenKey
                 ? `Property "${forbiddenKey}" is not allowed`
-                : strictSchemaProbe.success
-                    ? 'Catalog props schema must reject unknown properties'
-                    : 'Widget props do not match the catalog schema',
+                : strictSchemaProbe
+                    ? "Catalog props schema must reject unknown properties"
+                    : "Widget props do not match the catalog schema",
             widgetId: widget.id,
         };
     }
-    if (definition.dataKind === 'none') {
+    if (definition.dataKind === "none") {
         return widget.binding
             ? {
-                code: 'invalid_binding_pointer',
+                code: "invalid_binding_pointer",
                 path: `/widgets/${widgetIndex}/binding`,
-                message: 'This widget does not accept a data binding',
+                message: "This widget does not accept a data binding",
                 widgetId: widget.id,
             }
             : null;
@@ -217,23 +279,23 @@ function widgetIssue(widget, widgetIndex, definition, sources, policy) {
     const source = widget.binding ? sources.get(widget.binding.sourceId) : undefined;
     if (!source) {
         return {
-            code: 'unknown_data_source',
+            code: "unknown_data_source",
             path: `/widgets/${widgetIndex}/binding/sourceId`,
-            message: 'Widget binding must reference an existing data source',
+            message: "Widget binding must reference an existing data source",
             widgetId: widget.id,
         };
     }
-    const pointer = widget.binding?.pointer ?? '';
-    const resourceOneField = source.type === 'resource-one' ? resourceOnePointerField(pointer) : null;
-    const pointerIsValid = definition.dataKind === 'items'
-        ? source.type === 'resource-list' && pointer === '/items'
-        : (source.type === 'resource-list' && pointer === '/total')
+    const pointer = widget.binding?.pointer ?? "";
+    const resourceOneField = source.type === "resource-one" ? resourceOnePointerField(pointer) : null;
+    const pointerIsValid = definition.dataKind === "items"
+        ? source.type === "resource-list" && pointer === "/items"
+        : (source.type === "resource-list" && pointer === "/total")
             || resourceOneField !== null;
     if (!pointerIsValid) {
         return {
-            code: 'invalid_binding_pointer',
+            code: "invalid_binding_pointer",
             path: `/widgets/${widgetIndex}/binding/pointer`,
-            message: 'Binding pointer is not valid for this widget and data source',
+            message: "Binding pointer is not valid for this widget and data source",
             widgetId: widget.id,
             sourceId: source.id,
         };
@@ -241,10 +303,10 @@ function widgetIssue(widget, widgetIndex, definition, sources, policy) {
     const deniedReferencedField = referencedFieldIssue(widget, widgetIndex, definition, source, policy);
     if (deniedReferencedField)
         return deniedReferencedField;
-    if (source.type === 'resource-one' && resourceOneField !== null) {
+    if (source.type === "resource-one" && resourceOneField !== null) {
         if (!resourcePolicyFor(policy, source.resource)?.readFields.includes(resourceOneField)) {
             return {
-                code: 'field_denied',
+                code: "field_denied",
                 path: `/widgets/${widgetIndex}/binding/pointer`,
                 message: `Field "${resourceOneField}" is not readable`,
                 widgetId: widget.id,
@@ -262,7 +324,7 @@ function duplicateIdIssue(spec) {
     ];
     for (const entry of entries) {
         if (ids.has(entry.id))
-            return { code: 'duplicate_id', path: entry.path, message: `Duplicate id "${entry.id}"` };
+            return { code: "duplicate_id", path: entry.path, message: `Duplicate id "${entry.id}"` };
         ids.add(entry.id);
     }
     return null;
@@ -271,18 +333,18 @@ export function validateSurfaceSpec(input, catalog, policy) {
     const unsafeJson = jsonValueIssue(input);
     if (unsafeJson)
         return { ok: false, issues: [invalidJsonIssue(unsafeJson.path, unsafeJson.message)] };
-    const parsedSpec = surfaceSpecSchema.safeParse(input);
-    if (!parsedSpec.success)
-        return { ok: false, issues: schemaIssues(parsedSpec.error) };
-    const spec = parsedSpec.data;
+    if (!compiledSurfaceSpec.Check(input)) {
+        return { ok: false, issues: schemaErrors(compiledSurfaceSpec.Errors(input)) };
+    }
+    const spec = input;
     if (spec.schemaVersion !== SURFACE_SCHEMA_VERSION) {
-        return { ok: false, issues: [{ code: 'unsupported_schema_version', path: '/schemaVersion', message: `Expected ${SURFACE_SCHEMA_VERSION}` }] };
+        return { ok: false, issues: [{ code: "unsupported_schema_version", path: "/schemaVersion", message: `Expected ${SURFACE_SCHEMA_VERSION}` }] };
     }
     if (spec.catalogVersion !== catalog.version) {
-        return { ok: false, issues: [{ code: 'catalog_version_mismatch', path: '/catalogVersion', message: `Expected ${catalog.version}` }] };
+        return { ok: false, issues: [{ code: "catalog_version_mismatch", path: "/catalogVersion", message: `Expected ${catalog.version}` }] };
     }
     if (spec.dataSources.length > SURFACE_LIMITS.maxDataSources || spec.widgets.length > SURFACE_LIMITS.maxWidgets) {
-        return { ok: false, issues: [{ code: 'limit_exceeded', path: '', message: 'Surface exceeds the source or widget limit' }] };
+        return { ok: false, issues: [{ code: "limit_exceeded", path: "", message: "Surface exceeds the source or widget limit" }] };
     }
     const duplicateIssue = duplicateIdIssue(spec);
     if (duplicateIssue)
@@ -291,9 +353,9 @@ export function validateSurfaceSpec(input, catalog, policy) {
         const issue = sourcePolicyIssue(source, policy, sourceIndex);
         if (issue)
             return { ok: false, issues: [issue] };
-        if ((source.type === 'resource-list' && (source.filters?.length ?? 0) > SURFACE_LIMITS.maxFilters)
-            || (source.type === 'resource-list' && (source.sorters?.length ?? 0) > SURFACE_LIMITS.maxSorters)) {
-            return { ok: false, issues: [{ code: 'limit_exceeded', path: `/dataSources/${sourceIndex}`, message: 'Source exceeds the filter or sorter limit', sourceId: source.id }] };
+        if ((source.type === "resource-list" && (source.filters?.length ?? 0) > SURFACE_LIMITS.maxFilters)
+            || (source.type === "resource-list" && (source.sorters?.length ?? 0) > SURFACE_LIMITS.maxSorters)) {
+            return { ok: false, issues: [{ code: "limit_exceeded", path: `/dataSources/${sourceIndex}`, message: "Source exceeds the filter or sorter limit", sourceId: source.id }] };
         }
     }
     const sources = new Map(spec.dataSources.map((source) => [source.id, source]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/surface",
-  "version": "0.4.6",
+  "version": "0.6.0",
   "description": "Validated declarative surfaces for svadmin dashboards",
   "type": "module",
   "sideEffects": false,
@@ -25,20 +25,20 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": ">=0.34.2 <0.43.0",
-    "@svadmin/ui": ">=0.40.6 <0.61.0",
+    "@svadmin/core": ">=0.34.2 <0.46.0",
+    "@svadmin/ui": ">=0.40.6 <0.64.0",
     "svelte": "^5.56.8"
   },
   "dependencies": {
-    "zod": "^4.4.3"
+    "@sinclair/typebox": "^0.34.52"
   },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/svelte": "^5.4.2",
-    "@testing-library/user-event": "^14.6.4",
-    "happy-dom": "^20.11.2",
-    "vitest": "^4.1.10"
+    "@testing-library/user-event": "^14.6.6",
+    "happy-dom": "^20.11.12",
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "build": "node ../../node_modules/@sveltejs/package/svelte-package.js -i src -o dist",