@tailorkit/app 0.1.0-beta.43 → 0.1.0-beta.44

package/dist/{chunk-5B5RGL5W.js → chunk-MYK3WL3S.js}

@@ -9,27 +9,45 @@ import { RPCLink as FetchLink } from "@orpc/client/fetch";
 import { RPCLink } from "@orpc/client/websocket";
 
 // src/client/session.ts
-import { z } from "zod";
+import * as v2 from "valibot";
+
+// src/validation.ts
+import * as v from "valibot";
+var jsonValueSchema = v.lazy(
+  () => v.union([
+    v.string(),
+    v.pipe(v.number(), v.finite()),
+    v.boolean(),
+    v.null(),
+    v.array(jsonValueSchema),
+    v.record(v.string(), jsonValueSchema)
+  ])
+);
+
+// src/client/session.ts
 var isObjectValue = (value) => typeof value === "object" && value !== null;
-var identitySchema = z.object({
-  appId: z.string(),
-  deploymentId: z.string(),
-  expiresAt: z.number(),
-  installationId: z.string(),
-  projectId: z.string(),
-  scope: z.object({ name: z.string(), value: z.record(z.string(), z.json()) }),
-  subjectId: z.string().optional(),
-  toolUrl: z.string()
+var identitySchema = v2.object({
+  appId: v2.string(),
+  deploymentId: v2.string(),
+  expiresAt: v2.pipe(v2.number(), v2.finite()),
+  installationId: v2.string(),
+  projectId: v2.string(),
+  scope: v2.object({
+    name: v2.string(),
+    value: v2.record(v2.string(), jsonValueSchema)
+  }),
+  subjectId: v2.optional(v2.string()),
+  toolUrl: v2.string()
 });
-var sessionSchema = z.object({
-  expiresAt: z.number(),
-  identity: identitySchema.optional(),
-  subjectId: z.string().optional(),
-  token: z.string(),
-  toolUrl: z.string().optional(),
-  url: z.string()
+var sessionSchema = v2.object({
+  expiresAt: v2.pipe(v2.number(), v2.finite()),
+  identity: v2.optional(identitySchema),
+  subjectId: v2.optional(v2.string()),
+  token: v2.string(),
+  toolUrl: v2.optional(v2.string()),
+  url: v2.string()
 });
-var parseSession = (value) => sessionSchema.parse(value);
+var parseSession = (value) => v2.parse(sessionSchema, value);
 var APP_SESSION_RENEWAL_MS = 6e4;
 var freezeIdentity = (value) => {
   if (isObjectValue(value) && !Object.isFrozen(value)) {
@@ -80,11 +98,11 @@ var createSessionProvider = (options) => {
               "Unable to authorize the app backend"
             );
           }
-          const parsed = sessionSchema.safeParse(await response.json());
+          const parsed = v2.safeParse(sessionSchema, await response.json());
           if (!parsed.success) {
             throw new AppError("UNAVAILABLE", "Invalid app session");
           }
-          cached = parsed.data;
+          cached = parsed.output;
           if (cached.identity) {
             cached.identity = freezeIdentity(cached.identity);
           }

package/dist/{chunk-YX3JURMG.js → chunk-QDZXHVTU.js}

@@ -23,7 +23,7 @@ var defineServer = (functions) => {
 var defineDatabase = (definition) => Object.freeze({ relations: definition.relations });
 
 // src/server/builder.ts
-import { z } from "zod";
+import * as v from "valibot";
 var FunctionBuilder = class _FunctionBuilder {
   kind;
   args;
@@ -103,17 +103,30 @@ var FunctionBuilder = class _FunctionBuilder {
   }
 };
 var fn = Object.freeze({
-  action: new FunctionBuilder("action", z.undefined(), void 0, {}),
-  mutation: new FunctionBuilder("mutation", z.undefined(), void 0, {}),
-  query: new FunctionBuilder("query", z.undefined(), void 0, {})
+  action: new FunctionBuilder("action", v.undefined(), void 0, {}),
+  mutation: new FunctionBuilder("mutation", v.undefined(), void 0, {}),
+  query: new FunctionBuilder("query", v.undefined(), void 0, {})
 });
 
 // src/server/instances.ts
-import { z as z2 } from "zod";
-var addressSchema = z2.object({
-  path: z2.string().startsWith("/").max(1024),
-  slot: z2.string().min(1).max(255)
+import * as v2 from "valibot";
+var addressSchema = v2.object({
+  path: v2.pipe(v2.string(), v2.startsWith("/"), v2.maxLength(1024)),
+  slot: v2.pipe(v2.string(), v2.minLength(1), v2.maxLength(255))
 });
+var instanceResults = v2.pipe(
+  v2.array(
+    v2.object({
+      data: v2.unknown(),
+      key: v2.pipe(v2.string(), v2.minLength(1)),
+      metadata: v2.record(v2.string(), v2.unknown())
+    })
+  ),
+  v2.check(
+    (items) => new Set(items.map((item) => item.key)).size === items.length,
+    "Instance keys must be unique"
+  )
+);
 var registeredQueries = (functions) => {
   const queries = {};
   for (const [name, fn2] of Object.entries(functions)) {
@@ -139,7 +152,7 @@ var withInstanceResolvers = (app, resolvers) => {
   const queries = registeredQueries(app.functions);
   const registry = /* @__PURE__ */ new Map();
   for (const resolver of resolvers) {
-    addressSchema.parse(resolver);
+    v2.parse(addressSchema, resolver);
     let paths = registry.get(resolver.slot);
     if (!paths) {
       paths = /* @__PURE__ */ new Map();
@@ -150,45 +163,47 @@ var withInstanceResolvers = (app, resolvers) => {
         `Duplicate instance resolver for slot "${resolver.slot}" and path "${resolver.path}".`
       );
     }
-    const result = z2.array(
-      z2.object({
-        data: resolver.dataSchema,
-        key: z2.string().min(1),
-        metadata: z2.record(z2.string(), z2.unknown())
-      })
-    ).refine(
-      (items) => new Set(items.map((item) => item.key)).size === items.length,
-      {
-        message: "Instance keys must be unique"
-      }
-    );
-    paths.set(resolver.path, { resolver, result });
+    paths.set(resolver.path, resolver);
   }
   const instances = {
     resolve: action({
-      args: addressSchema.extend({
-        context: z2.record(z2.string(), z2.unknown())
+      args: v2.object({
+        ...addressSchema.entries,
+        context: v2.record(v2.string(), v2.unknown())
       }),
       functions: queries,
       handler: async ({ args, identity, signal, queries: queriesValue }) => {
-        const entry = registry.get(args.slot)?.get(args.path);
-        if (!entry) {
+        const resolver = registry.get(args.slot)?.get(args.path);
+        if (!resolver) {
           throw new AppError("NOT_FOUND", "Instance resolver not found");
         }
-        const value = await entry.resolver.resolve({
+        const value = await resolver.resolve({
           context: args.context,
           identity,
           queries: queriesValue,
           signal
         });
-        const result = entry.result.safeParse(value);
+        const result = v2.safeParse(instanceResults, value);
         if (!result.success) {
           throw new AppError(
             "INTERNAL_SERVER_ERROR",
             "Invalid function result"
           );
         }
-        return result.data;
+        return await Promise.all(
+          result.output.map(async (item) => {
+            const parsed = await resolver.dataSchema["~standard"].validate(
+              item.data
+            );
+            if (parsed.issues) {
+              throw new AppError(
+                "INTERNAL_SERVER_ERROR",
+                "Invalid function result"
+              );
+            }
+            return { ...item, data: parsed.value };
+          })
+        );
       }
     })
   };

package/dist/{chunk-Q6X2VQKX.js → chunk-YFKW5FBP.js}

@@ -1,7 +1,7 @@
 import {
   createClient,
   reference
-} from "./chunk-5B5RGL5W.js";
+} from "./chunk-MYK3WL3S.js";
 import {
   AppError,
   appError
@@ -566,7 +566,7 @@ var createFileClient = (options) => {
 };
 
 // src/client/tools.ts
-import { z } from "zod";
+import * as v from "valibot";
 var executeServerTool = async (session, path, input, request = globalThis.fetch, signal) => {
   const response = await request(session.url, {
     body: JSON.stringify({ input, path, requestId: crypto.randomUUID() }),
@@ -593,7 +593,10 @@ var executeServerTool = async (session, path, input, request = globalThis.fetch,
       "Tool call failed"
     );
   }
-  return z.object({ output: z.unknown().optional() }).parse(await response.json()).output;
+  return v.parse(
+    v.object({ output: v.optional(v.unknown()) }),
+    await response.json()
+  ).output;
 };
 var callTool = async (kind, path, input) => {
   const bridge = globalThis.__tailorkitTools;

package/dist/client/reference.d.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { FunctionResult, Functions } from "#server/functions";
 export interface Reference<K extends "query" | "mutation" | "action", I, O> {
     readonly name: string;
@@ -12,9 +12,9 @@ export declare const reference: <K extends "query" | "mutation" | "action", I, O
 export type References<F> = {
     readonly [N in keyof F]: F[N] extends {
         kind: infer K extends "query" | "mutation" | "action";
-        args: infer A extends z.ZodType;
+        args: infer A extends StandardSchemaV1;
         handler: (...args: never[]) => infer _Output;
-    } ? Reference<K, z.input<A>, FunctionResult<F[N]>> : F[N] extends Functions ? References<F[N]> : never;
+    } ? Reference<K, StandardSchemaV1.InferInput<A>, FunctionResult<F[N]>> : F[N] extends Functions ? References<F[N]> : never;
 };
 /** Browser references inferred directly from the server's exported function type. */
 export declare const createApi: <F extends Functions>() => References<F>;

package/dist/client/session.d.ts

@@ -1,26 +1,6 @@
-import { z } from "zod";
+import * as v from "valibot";
 import type { Identity } from "#server/functions";
-declare const sessionSchema: z.ZodObject<{
-    expiresAt: z.ZodNumber;
-    identity: z.ZodOptional<z.ZodObject<{
-        appId: z.ZodString;
-        deploymentId: z.ZodString;
-        expiresAt: z.ZodNumber;
-        installationId: z.ZodString;
-        projectId: z.ZodString;
-        scope: z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-        }, z.core.$strip>;
-        subjectId: z.ZodOptional<z.ZodString>;
-        toolUrl: z.ZodString;
-    }, z.core.$strip>>;
-    subjectId: z.ZodOptional<z.ZodString>;
-    token: z.ZodString;
-    toolUrl: z.ZodOptional<z.ZodString>;
-    url: z.ZodString;
-}, z.core.$strip>;
-export declare const parseSession: (value: Parameters<typeof sessionSchema.parse>[0]) => Session;
+export declare const parseSession: (value: Parameters<typeof v.parse>[1]) => Session;
 export interface Session {
     toolUrl?: string;
     identity?: Identity;
@@ -38,4 +18,3 @@ export declare const createSessionProvider: (options: {
 }) => (input: {
     refresh: boolean;
 }) => Promise<Session>;
-export {};

package/dist/client-connection.js

@@ -3,7 +3,7 @@ import {
   createSessionProvider,
   parseSession,
   reference
-} from "./chunk-5B5RGL5W.js";
+} from "./chunk-MYK3WL3S.js";
 import {
   AppError
 } from "./chunk-7ZQPXG7O.js";

package/dist/client.js

@@ -9,13 +9,13 @@ import {
   useAction,
   useMutation,
   useQuery
-} from "./chunk-Q6X2VQKX.js";
+} from "./chunk-YFKW5FBP.js";
 import {
   createApi,
   createClient,
   createSessionProvider,
   reference
-} from "./chunk-5B5RGL5W.js";
+} from "./chunk-MYK3WL3S.js";
 import {
   AppError,
   appError

package/dist/index.js

@@ -9,13 +9,13 @@ import {
   useAction,
   useMutation,
   useQuery
-} from "./chunk-Q6X2VQKX.js";
+} from "./chunk-YFKW5FBP.js";
 import {
   createApi,
   createClient,
   createSessionProvider,
   reference
-} from "./chunk-5B5RGL5W.js";
+} from "./chunk-MYK3WL3S.js";
 import {
   action,
   and,
@@ -43,7 +43,7 @@ import {
   table,
   text,
   withInstanceResolvers
-} from "./chunk-YX3JURMG.js";
+} from "./chunk-QDZXHVTU.js";
 import {
   AppError,
   appError

package/dist/protocol.d.ts

@@ -1,19 +1,19 @@
 import type { ContractRouterClient } from "@orpc/contract";
-import { z } from "zod";
-export declare const invocationSchema: z.ZodObject<{
-    args: z.ZodOptional<z.ZodUnknown>;
-    name: z.ZodString;
-}, z.core.$strict>;
-export type Invocation = z.infer<typeof invocationSchema>;
+import * as v from "valibot";
+export declare const invocationSchema: v.StrictObjectSchema<{
+    readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+}, undefined>;
+export type Invocation = v.InferOutput<typeof invocationSchema>;
 export type MutationInvocation = Invocation & {
     requestId: string;
 };
 /** Public wire contract; implementations and clients both depend on this definition. */
 export declare const appContract: {
-    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        args: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodString;
-    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
         CONFLICT: {};
         FORBIDDEN: {};
@@ -23,11 +23,11 @@ export declare const appContract: {
         UNAUTHORIZED: {};
         UNAVAILABLE: {};
     }>;
-    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        args: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodString;
-        requestId: z.ZodUUID;
-    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+        readonly requestId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
         CONFLICT: {};
         FORBIDDEN: {};
@@ -37,10 +37,10 @@ export declare const appContract: {
         UNAUTHORIZED: {};
         UNAVAILABLE: {};
     }>;
-    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        args: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodString;
-    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<unknown, unknown>, {
         BAD_REQUEST: {};
         CONFLICT: {};
         FORBIDDEN: {};
@@ -50,10 +50,10 @@ export declare const appContract: {
         UNAUTHORIZED: {};
         UNAVAILABLE: {};
     }>;
-    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
-        args: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodString;
-    }, z.core.$strict>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
+    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<v.StrictObjectSchema<{
+        readonly args: v.OptionalSchema<v.UnknownSchema, undefined>;
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 512, undefined>, v.RegexAction<string, undefined>]>;
+    }, undefined>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
         BAD_REQUEST: {};
         CONFLICT: {};
         FORBIDDEN: {};

package/dist/protocol.js

@@ -1,10 +1,14 @@
 // src/protocol.ts
 import { oc, type } from "@orpc/contract";
-import { z } from "zod";
-var invocationSchema = z.strictObject({
-  args: z.unknown().optional(),
-  name: z.string().max(512).regex(
-    /^(?:[a-zA-Z][a-zA-Z0-9_]{0,63}|_tailorkit)(?:\.[a-zA-Z][a-zA-Z0-9_]{0,63})*$/u
+import * as v from "valibot";
+var invocationSchema = v.strictObject({
+  args: v.optional(v.unknown()),
+  name: v.pipe(
+    v.string(),
+    v.maxLength(512),
+    v.regex(
+      /^(?:[a-zA-Z][a-zA-Z0-9_]{0,63}|_tailorkit)(?:\.[a-zA-Z][a-zA-Z0-9_]{0,63})*$/u
+    )
   )
 });
 var procedure = oc.errors({
@@ -19,7 +23,12 @@ var procedure = oc.errors({
 });
 var appContract = {
   actions: procedure.input(invocationSchema).output(type()),
-  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
+  mutations: procedure.input(
+    v.strictObject({
+      ...invocationSchema.entries,
+      requestId: v.pipe(v.string(), v.uuid())
+    })
+  ).output(type()),
   queries: procedure.input(invocationSchema).output(type()),
   // A pass-through type schema preserves the private hibernation iterator instance.
   subscribe: procedure.input(invocationSchema).output(type())

package/dist/server/builder.d.ts

@@ -1,45 +1,46 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
-import { z } from "zod";
+import * as v from "valibot";
 import type { DatabaseDefinition } from "#database/definition";
 import type { MutationDatabase, QueryDatabase } from "#database/types";
 import type { ActionContext, EmptyFunctions, FunctionKind, Functions, Identity } from "./functions";
-type HandlerContext<K extends FunctionKind, A extends z.ZodType, F extends Functions, D extends AnyRelations> = {
-    input: z.output<A>;
+type HandlerContext<K extends FunctionKind, A extends StandardSchemaV1, F extends Functions, D extends AnyRelations> = {
+    input: StandardSchemaV1.InferOutput<A>;
 } & (K extends "action" ? ActionContext<F> : {
     db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
     identity: Identity;
 });
-type OutputInput<R> = R extends z.ZodType ? z.input<R> : unknown;
+type OutputInput<R> = R extends StandardSchemaV1 ? StandardSchemaV1.InferInput<R> : unknown;
 type HandlerOutput<K, O> = K extends "action" ? O | Promise<O> : O & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
-type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends Functions, D extends AnyRelations> = {
+type BuiltFunction<K extends FunctionKind, A extends StandardSchemaV1, R, O, F extends Functions, D extends AnyRelations> = {
     readonly kind: K;
     readonly args: A;
     readonly database?: DatabaseDefinition<D>;
     readonly handler: (context: Omit<HandlerContext<K, A, F, D>, "input"> & {
-        args: z.output<A>;
+        args: StandardSchemaV1.InferOutput<A>;
     }) => HandlerOutput<K, O>;
-} & (R extends z.ZodType ? {
+} & (R extends StandardSchemaV1 ? {
     readonly result: R;
 } : unknown) & (K extends "action" ? {
     readonly functions: F;
 } : unknown);
 /** Immutable builders preserve the validated input and wire output types at every step. */
-declare class FunctionBuilder<K extends FunctionKind, A extends z.ZodType, R extends z.ZodType | undefined = undefined, F extends Functions = EmptyFunctions, D extends AnyRelations = EmptyRelations> {
+declare class FunctionBuilder<K extends FunctionKind, A extends StandardSchemaV1, R extends StandardSchemaV1 | undefined = undefined, F extends Functions = EmptyFunctions, D extends AnyRelations = EmptyRelations> {
     private readonly kind;
     private readonly args;
     private readonly result;
     private readonly calls;
     private readonly databaseDefinition;
     constructor(kind: K, args: A, result: R, calls: F, database?: DatabaseDefinition<D>);
-    input<S extends z.ZodType>(schema: S): FunctionBuilder<K, S, R, F, D>;
-    output<S extends z.ZodType>(schema: S): FunctionBuilder<K, A, S, F, D>;
+    input<S extends StandardSchemaV1>(schema: S): FunctionBuilder<K, S, R, F, D>;
+    output<S extends StandardSchemaV1>(schema: S): FunctionBuilder<K, A, S, F, D>;
     functions<const G extends Functions>(this: FunctionBuilder<"action", A, R, F, D>, functions: G): FunctionBuilder<"action", A, R, G, D>;
     database<const E extends AnyRelations>(this: FunctionBuilder<K, A, R, F, D> & (K extends "action" ? never : unknown), database: DatabaseDefinition<E>): FunctionBuilder<K, A, R, F, E>;
     handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F, D>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F, D>;
 }
 export declare const fn: Readonly<{
-    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}, EmptyRelations>;
-    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}, EmptyRelations>;
-    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    action: FunctionBuilder<"action", v.UndefinedSchema<undefined>, undefined, {}, EmptyRelations>;
+    mutation: FunctionBuilder<"mutation", v.UndefinedSchema<undefined>, undefined, {}, EmptyRelations>;
+    query: FunctionBuilder<"query", v.UndefinedSchema<undefined>, undefined, {}, EmptyRelations>;
 }>;
 export {};

package/dist/server/functions.d.ts

@@ -1,14 +1,15 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
-import type { z } from "zod";
 import type { TailorKitServerTools } from "#client/tools";
 import type { DatabaseDefinition } from "#database/definition";
 import type { QueryDatabase, MutationDatabase } from "#database/types";
+import type { JsonValue } from "#validation";
 export type EmptyFunctions = Record<never, never>;
 export interface Identity {
     readonly subjectId?: string;
     readonly scope: {
         name: string;
-        value: Record<string, z.output<ReturnType<typeof z.json>>>;
+        value: Record<string, JsonValue>;
     };
     readonly toolUrl: string;
     readonly projectId: string;
@@ -19,8 +20,8 @@ export interface Identity {
 }
 export type FunctionKind = "query" | "mutation" | "action";
 export type FunctionResult<D> = D extends {
-    result: infer R extends z.ZodType;
-} ? z.output<R> : D extends {
+    result: infer R extends StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<R> : D extends {
     handler: (context: never) => infer O;
 } ? Awaited<O> : never;
 export type FunctionCalls<F, K extends "query" | "mutation"> = {
@@ -29,13 +30,19 @@ export type FunctionCalls<F, K extends "query" | "mutation"> = {
     } ? F[N] extends {
         kind: K;
     } ? N : never : N]: F[N] extends {
-        args: infer A extends z.ZodType;
+        args: infer A extends StandardSchemaV1;
         handler: (context: never) => infer _Output;
-    } ? K extends "mutation" ? (...args: undefined extends z.input<A> ? [args?: z.input<A>, options?: {
-        requestId?: string;
-    }] : [args: z.input<A>, options?: {
-        requestId?: string;
-    }]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends z.input<A> ? [args?: z.input<A>] : [args: z.input<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
+    } ? K extends "mutation" ? (...args: undefined extends StandardSchemaV1.InferInput<A> ? [
+        args?: StandardSchemaV1.InferInput<A>,
+        options?: {
+            requestId?: string;
+        }
+    ] : [
+        args: StandardSchemaV1.InferInput<A>,
+        options?: {
+            requestId?: string;
+        }
+    ]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends StandardSchemaV1.InferInput<A> ? [args?: StandardSchemaV1.InferInput<A>] : [args: StandardSchemaV1.InferInput<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
 };
 export interface ActionContext<F extends Functions = EmptyFunctions> {
     readonly identity: Identity;
@@ -46,52 +53,52 @@ export interface ActionContext<F extends Functions = EmptyFunctions> {
     readonly queries: FunctionCalls<F, "query">;
     readonly mutations: FunctionCalls<F, "mutation">;
 }
-export interface FunctionDefinition<K extends FunctionKind, A extends z.ZodType, O, F extends Functions = EmptyFunctions, D extends AnyRelations = EmptyRelations> {
+export interface FunctionDefinition<K extends FunctionKind, A extends StandardSchemaV1, O, F extends Functions = EmptyFunctions, D extends AnyRelations = EmptyRelations> {
     readonly kind: K;
     readonly args: A;
     readonly database?: K extends "action" ? never : DatabaseDefinition<D>;
-    readonly result?: z.ZodType<O>;
+    readonly result?: StandardSchemaV1<unknown, O>;
     readonly handler: (context: {
-        args: z.output<A>;
+        args: StandardSchemaV1.InferOutput<A>;
     } & (K extends "action" ? ActionContext<F> : {
         db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
         identity: Identity;
     })) => K extends "action" ? O | Promise<O> : O;
 }
-export declare const query: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, EmptyFunctions, D>, "kind"> & {
+export declare const query: <A extends StandardSchemaV1, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, EmptyFunctions, D>, "kind"> & {
     handler: FunctionDefinition<"query", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
 }) => Readonly<{
     args: A;
     database?: DatabaseDefinition<D> | undefined;
-    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
     handler: FunctionDefinition<"query", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
     kind: "query";
 }>;
-export declare const mutation: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, EmptyFunctions, D>, "kind"> & {
+export declare const mutation: <A extends StandardSchemaV1, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, EmptyFunctions, D>, "kind"> & {
     handler: FunctionDefinition<"mutation", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
 }) => Readonly<{
     args: A;
     database?: DatabaseDefinition<D> | undefined;
-    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
     handler: FunctionDefinition<"mutation", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
     kind: "mutation";
 }>;
-export declare const action: <A extends z.ZodType, O, const F extends Functions = EmptyFunctions>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
+export declare const action: <A extends StandardSchemaV1, O, const F extends Functions = EmptyFunctions>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
     functions?: F;
 }) => Readonly<{
     args: A;
     database?: undefined;
-    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
     handler: (context: {
-        args: z.infer<A>;
+        args: StandardSchemaV1.InferOutput<A>;
     } & ActionContext<F>) => O | Promise<O>;
     functions?: F;
     kind: "action";
 }>;
 export interface RegisteredFunction<TOutput = unknown> {
     kind: FunctionKind;
-    args: z.ZodType;
-    result?: z.ZodType;
+    args: StandardSchemaV1;
+    result?: StandardSchemaV1;
     handler: (context: never) => TOutput;
     functions?: Functions;
     database?: DatabaseDefinition;

package/dist/server/instances.d.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { ViewDataFields } from "#views";
 import type { AppDefinition, Identity } from "./functions";
 interface InstanceResolver<TOutput = unknown> {
     slot: string;
     path: string;
-    dataSchema: z.ZodType;
+    dataSchema: StandardSchemaV1;
     resolve: (context: {
         context: ViewDataFields;
         identity: Identity;

package/dist/server.js

@@ -25,7 +25,7 @@ import {
   table,
   text,
   withInstanceResolvers
-} from "./chunk-YX3JURMG.js";
+} from "./chunk-QDZXHVTU.js";
 import {
   AppError
 } from "./chunk-7ZQPXG7O.js";

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const jsonValueSchema: v.GenericSchema<JsonValue>;

package/dist/views.d.ts

@@ -1,6 +1,6 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { h } from "preact";
 import type { ComponentChild, ComponentChildren, VNode } from "preact";
-import type { z } from "zod";
 import type { FunctionCalls, Identity } from "./server/functions";
 export interface TailorKitViews {
 }
@@ -20,10 +20,10 @@ export interface InstanceResolverContext<TPath extends AppViewPath> {
     signal: AbortSignal;
     queries: FunctionCalls<TailorKitServerFunctions, "query">;
 }
-export interface ViewInstances<TPath extends AppViewPath, TSchema extends z.ZodType> {
+export interface ViewInstances<TPath extends AppViewPath, TSchema extends StandardSchemaV1> {
     dataSchema: TSchema;
     /** Runs on the app server. Only registered queries are available. */
-    resolve: (context: InstanceResolverContext<TPath>) => ViewInstance<z.input<TSchema>>[] | Promise<ViewInstance<z.input<TSchema>>[]>;
+    resolve: (context: InstanceResolverContext<TPath>) => ViewInstance<StandardSchemaV1.InferInput<TSchema>>[] | Promise<ViewInstance<StandardSchemaV1.InferInput<TSchema>>[]>;
 }
 export type SlotName = keyof TailorKitSlots & string;
 export type ViewPath = Extract<keyof TailorKitViews & string, `/${string}`>;
@@ -93,7 +93,7 @@ export type TailorKitClientWithMeta<TViews extends SlotDefinitions = SlotDefinit
     $meta: TailorKitClientMeta;
     $runtime: TailorKitClientRuntime;
 };
-type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema extends z.ZodType> = {
+type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema extends StandardSchemaV1> = {
     [S in TSlot]: {
         slot: S;
         view: TPath;
@@ -110,13 +110,13 @@ type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema exte
 }[TSlot];
 /** In .view.tsx files, the builder supplies the slot and filename-derived path.
  * An explicit view must match the file path and provides precise host context typing. */
-export declare function defineView<const TPath extends AppViewPath = AppViewPath, TSchema extends z.ZodType = z.ZodType>(options: {
+export declare function defineView<const TPath extends AppViewPath = AppViewPath, TSchema extends StandardSchemaV1 = StandardSchemaV1>(options: {
     slot?: never;
     view?: TPath;
     component: View;
     instances?: ViewInstances<TPath, TSchema>;
-}): ViewDefinition<TPath, z.output<TSchema>>;
-export declare function defineView<const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends z.ZodType>(options: ViewOptions<TPath, TSlot, TSchema>): ViewDefinition<TPath, z.output<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
+}): ViewDefinition<TPath, StandardSchemaV1.InferOutput<TSchema>>;
+export declare function defineView<const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends StandardSchemaV1>(options: ViewOptions<TPath, TSlot, TSchema>): ViewDefinition<TPath, StandardSchemaV1.InferOutput<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
 export declare const createRemoteComponent: <TProps extends object, TChildren extends boolean = false>(name: string, options?: {
     callbacks?: Record<string, number>;
     children?: TChildren;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailorkit/app",
-  "version": "0.1.0-beta.43",
+  "version": "0.1.0-beta.44",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -64,9 +64,10 @@
     "@nanostores/preact": "1.1.1",
     "@orpc/client": "2.0.0-beta.40",
     "@orpc/contract": "2.0.0-beta.40",
+    "@standard-schema/spec": "^1.1.0",
     "drizzle-orm": "1.0.0-rc.4-5d5b77c",
     "nanostores": "1.5.5",
-    "zod": "^4.6.5"
+    "valibot": "^1.5.0"
   },
   "devDependencies": {
     "@tailorkit/config": "0.0.0",
@@ -76,7 +77,8 @@
     "tsup": "^8.5.1",
     "typescript": "^7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
-    "vite-plus": "1.1.0"
+    "vite-plus": "1.1.0",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
     "preact": "^11.0.0"