cogsbox-shape 0.5.204 → 0.5.206

package/README.md

@@ -33,14 +33,14 @@ Traditional approaches require defining these layers separately, leading to type
 Define a field by chaining methods. Each step is optional — use only what you need.
 
 ```
-s.sqlite()/s.postgres()/s.mysql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
+s.sqlite()/s.postgres()/s.mysql()  →  .client()  →  .clientCheck()  →  .server()  →  .transform()
 ```
 
 | Method                            | Purpose                                                        |
 | --------------------------------- | -------------------------------------------------------------- |
 | `s.sqlite/postgres/mysql({ type, sqlOnly })` | Database column type. `sqlOnly` excludes from client layer. |
-| `.clientInput({ value, schema })` | Client-side input schema and default value for new records.    |
-| `.client(fn)`                     | Client-side validation on the final client union type.         |
+| `.client({ value, schema })`      | Client-side input schema and default value for new records.    |
+| `.clientCheck(fn)`                | Client-side validation on the final client union type.         |
 | `.server(fn)`                     | Server-side validation. Stricter rules before database writes. |
 | `.transform({ toClient, toDb })`  | Converts between database and client representations.          |
 
@@ -88,47 +88,49 @@ s.mysql({ type: "enum", values: ["draft", "published"] });
 // SQL: ENUM('draft', 'published')
 ```
 
-### 2. Client Input — Defaults and Client-Side Validation
+### 2. Client — Defaults and Client-Side Validation
 
-`.clientInput()` sets the default value and client-side validation type for new records.
+`.client()` sets the default value and client-side validation type for new records.
 
 ```typescript
 const userSchema = schema({
   _tableName: "users",
   // DB stores auto-increment integers, but new records need a temp string ID
-  id: s.sqlite({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).client({
     value: () => crypto.randomUUID(),
     schema: z.string(),
   }),
-  // clientInput type: string (just the user's schema)
+  // client type: string (just the user's schema)
   // Default value: a generated UUID string
 
   // Simple default without type override
-  name: s.sqlite({ type: "varchar" }).clientInput({ value: "Anonymous" }),
-  // clientInput type: string (inherits from SQL)
+  name: s.sqlite({ type: "varchar" }).client({ value: "Anonymous" }),
+  // client type: string (inherits from SQL)
   // Default value: "Anonymous"
 
-  // Type-only override (no default value change)
-  count: s.sqlite({ type: "int" }).clientInput(() => z.number().min(0)),
-  // clientInput type: number (with min validation)
-  // Default value: inferred from type (0 for number)
+  // Type-only override; default is inferred from the client schema
+  count: s.sqlite({ type: "int" }).client(() => z.number().min(0)),
+  // client type: number (with min validation)
+  // Default value: inferred from the client schema (0 for number)
 });
 ```
 
-**Note:** The final `client` schema is a union of `sql | clientInput` types, representing the complete app state after transforms.
+**Note:** The final `client` schema is a union of `sql | client` types, representing the complete app state after transforms.
+
+`generateDefaults()` uses the client schema to pick a default when no explicit `value` is provided. `toClient()` stays for DB-shaped data.
 
-### 3. Client — Client-Side Validation
+### 3. Client Check — Client-Side Validation
 
-`.client()` adds validation rules to the final `client` schema (the union of sql | clientInput). Use it for client-side validation that operates on the complete client type.
+`.clientCheck()` adds validation rules to the final `client` schema (the union of sql | client). Use it for client-side validation that operates on the complete client type.
 
 ```typescript
 name: s.sqlite({ type: "varchar" })
-  .clientInput({ value: "" })
-  .client((tools) => tools.clientInput.min(3, "Too short"))
-  .server((tools) => tools.clientInput.min(5, "Must be at least 5 chars")),
+  .client({ value: "" })
+  .clientCheck((tools) => tools.client.min(3, "Too short"))
+  .server((tools) => tools.client.min(5, "Must be at least 5 chars")),
 ```
 
-The `.client()` callback receives `tools` with `sql`, `clientInput`, and `client` schemas.
+The `.clientCheck()` callback receives `tools` with `sql`, `client`, and `clientCheck` schemas.
 
 ### 4. Server — Server-Side Validation
 
@@ -152,8 +154,8 @@ The callback receives the previous schema in the chain so you can refine it:
 ```typescript
 name: s
   .sqlite({ type: "varchar" })
-  .clientInput(() => z.string().trim())
-  .server(({ clientInput }) => clientInput.min(2, "Too short")),
+  .client(() => z.string().trim())
+  .server(({ client }) => client.min(2, "Too short")),
 ```
 
 ### 5. Transform — Convert Between Layers
@@ -163,7 +165,7 @@ name: s
 ```typescript
 status: s
   .sqlite({ type: "int" })                              // DB: 0 or 1
-  .clientInput(() => z.enum(["active", "inactive"])) // Client input: string enum
+  .client(() => z.enum(["active", "inactive"])) // Client input: string enum
   .transform({
     toClient: (dbValue) => dbValue === 1 ? "active" : "inactive",
     toDb: (clientValue) => clientValue === "active" ? 1 : 0,
@@ -193,13 +195,13 @@ const userSchema = schema({
 
 #### Client-Only Fields
 
-By skipping `s.sqlite()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
+By skipping `s.sqlite()` entirely and just using `s.client()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
 
 ```typescript
 const products = schema({
   _tableName: "products",
   price: s.sqlite({ type: "int" }),
-  formattedPrice: s.clientInput(""), // Client-only field!
+  formattedPrice: s.client(""), // Client-only field!
 });
 ```
 
@@ -213,11 +215,11 @@ const products = schema({
 ```typescript
 const users = schema({
   _tableName: "users",
-  firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
-  lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
+  firstName: s.sqlite({ type: "varchar" }).client({ value: "John" }),
+  lastName: s.sqlite({ type: "varchar" }).client({ value: "Doe" }),
 
-  // Virtual field. It exists in app/view state, not SQL.
-  fullName: s.clientInput(""),
+  // Virtual field. It exists in app/view state, not SQL.
+  fullName: s.client(""),
 
   // Hidden DB column. It is written to SQL, but not sent to the client.
   searchIndex: s.sqlite({ type: "varchar", sqlOnly: true }),
@@ -235,19 +237,19 @@ During partial ORM updates, DB-backed derivations fetch only missing dependency
 
 ### 7. Refinement (`.refine()`)
 
-`.refine()` adds cross-field validation rules that the entire row must satisfy. Unlike `.client()`/`.server()` which validate individual fields, `refine` can check relationships between fields.
+`.refine()` adds cross-field validation rules that the entire row must satisfy. Unlike `.clientCheck()`/`.server()` which validate individual fields, `refine` can check relationships between fields.
 
 ```typescript
 const events = schema({
   _tableName: "events",
   id: s.sqlite({ type: "int", pk: true }),
-  startDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
-  endDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
-  content: s.sqlite({ type: "varchar", nullable: true }).clientInput({
+  startDate: s.sqlite({ type: "varchar" }).client({ value: "" }),
+  endDate: s.sqlite({ type: "varchar" }).client({ value: "" }),
+  content: s.sqlite({ type: "varchar", nullable: true }).client({
     value: null,
     schema: z.string().nullable(),
   }),
-  isPublished: s.sqlite({ type: "boolean" }).clientInput({ value: false }),
+  isPublished: s.sqlite({ type: "boolean" }).client({ value: false }),
 }).refine((r) => [
   r("server", (row) => {
     const errors: { path: string[]; message: string }[] = [];
@@ -276,8 +278,8 @@ The `refine()` method takes a callback that receives an `r` helper function. Eac
 | Layer | Applies to | Purpose |
 |-------|-----------|---------|
 | `"server"` | `parseForDb()`, `server` schema | Cross-field validation before DB writes |
-| `"client"` | `client` schema | Cross-field validation on client output |
-| `"clientInput"` | `clientInput` schema | Cross-field validation on raw client input |
+| `"clientCheck"` | `clientCheck` schema | Cross-field validation on client output |
+| `"client"` | `client` schema | Cross-field validation on raw client input |
 | `"sql"` | `parseFromDb()`, `sql` schema | Cross-field validation on DB reads |
 | `"all"` | all of the above | Universal cross-field validation |
 | `string[]` | specified layers | Apply to multiple layers at once |
@@ -312,10 +314,10 @@ The returned schema object has a clear separation of concerns:
 ```typescript
 const schema = createSchema(mySchema);
 
-schema.schemas; // { sql, clientInput, client, server } — Zod schemas
+schema.schemas; // { sql, client, clientChecked, server } — Zod schemas
 schema.transforms; // { toClient, toDb, parseForDb, parseFromDb } — transformations
 schema.defaults; // Default values for forms
-schema.generateDefaults; // Function to generate fresh defaults (executes randomizers)
+schema.generateDefaults; // Function to generate fresh client defaults (executes randomizers)
 schema.pk; // Primary key field names
 schema.clientPk; // Client-side primary key field names
 schema.isClientRecord; // Function to check if a record is client-created
@@ -334,7 +336,7 @@ import { s, schema, createSchema } from "cogsbox-shape";
 
 const contactSchema = schema({
   _tableName: "contacts",
-  id: s.sqlite({ type: "int", pk: true }).clientInput({
+  id: s.sqlite({ type: "int", pk: true }).client({
     value: () => `new_${crypto.randomUUID().slice(0, 8)}`,
     schema: z.string(),
   }),
@@ -342,7 +344,7 @@ const contactSchema = schema({
   email: s.sqlite({ type: "varchar" }).server(({ sql }) => sql.email()),
   isActive: s
     .sqlite({ type: "boolean", default: true })
-    .clientInput(() => z.boolean())
+    .client(() => z.boolean())
     .transform({
       toClient: (val) => Boolean(val),
       toDb: (val) => (val ? 1 : 0),
@@ -352,7 +354,7 @@ const contactSchema = schema({
 const schema = createSchema(contactSchema);
 
 // Access schemas directly
-const { sql, clientInput, client, server } = schema.schemas;
+const { sql, client, clientChecked, server } = schema.schemas;
 const { defaults, generateDefaults } = schema;
 
 // Transforms for converting between layers

package/cogsbox-shape-state/dist/example/type-hover-example.js

@@ -13,11 +13,11 @@ const taskItemSchema = z.object({
 });
 const taskManagerSchema = schema({
     _tableName: "client",
-    tasks: s.clientInput({
+    tasks: s.client({
         value: [],
         schema: z.array(taskItemSchema),
     }),
-    filter: s.clientInput({
+    filter: s.client({
         value: "all",
         schema: z.string(),
     }),

package/cogsbox-shape-state/dist/plugin.d.ts

@@ -41,6 +41,7 @@ type FormUpdateParams = {
         message: string;
         code?: string;
     }>) => void;
+    clearZodErrors: (paths: string[][]) => void;
 };
 export declare function wireShapeValidationOptions(box: ShapeSchemaBox, params: TransformStateParams): void;
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */

package/cogsbox-shape-state/dist/plugin.js

@@ -1,5 +1,12 @@
 import { createPluginContext } from "cogsbox-state";
 import { z } from "zod";
+function pathKey(path) {
+    return path.join("\0");
+}
+function resolveRelatedPaths(blurPath, relatedFields) {
+    const parent = blurPath.slice(0, -1);
+    return [...relatedFields].map((field) => [...parent, field]);
+}
 function mapZodIssues(issues) {
     return issues.map((issue) => ({
         path: issue.path.map(String),
@@ -21,6 +28,10 @@ function getRelatedFields(entry, field) {
     }
     return related;
 }
+function issueMatchesRelatedFields(issue, relatedFields) {
+    const leaf = String(issue.path.at(-1) ?? "");
+    return relatedFields.has(leaf);
+}
 export function wireShapeValidationOptions(box, params) {
     const entry = box[params.stateKey];
     if (!entry)
@@ -46,12 +57,21 @@ export function validateShapeRefines(box, params) {
     const relatedFields = getRelatedFields(entry, field);
     if (!relatedFields)
         return;
+    const relatedPaths = resolveRelatedPaths(params.path, relatedFields);
     const result = clientSchema.safeParse(params.getState());
-    if (result.success)
+    if (result.success) {
+        params.clearZodErrors(relatedPaths);
         return;
-    const issues = result.error.issues.filter((issue) => relatedFields.has(String(issue.path[0])));
-    if (issues.length > 0) {
-        params.addZodErrors(mapZodIssues(issues));
+    }
+    const issues = result.error.issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields));
+    const mapped = mapZodIssues(issues);
+    const activeKeys = new Set(mapped.map((entry) => pathKey(entry.path)));
+    const stalePaths = relatedPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
+    if (stalePaths.length > 0) {
+        params.clearZodErrors(stalePaths);
+    }
+    if (mapped.length > 0) {
+        params.addZodErrors(mapped);
     }
 }
 function buildInitialState(box) {

package/dist/schema.d.ts

@@ -64,49 +64,49 @@ type SQLToZodType<T extends SQLTypeInput, TDefault extends boolean> = T["pk"] ex
 type ZodTypeFromPrimitive<T> = T extends string ? z.ZodString : T extends number ? z.ZodNumber : T extends boolean ? z.ZodBoolean : T extends Date ? z.ZodDate : z.ZodAny;
 type CollapsedUnion<A extends z.ZodTypeAny, B extends z.ZodTypeAny> = A extends B ? (B extends A ? A : z.ZodUnion<[A, B]>) : z.ZodUnion<[A, B]>;
 export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> {
-    clientInput<const TValue, const TSchema extends z.ZodTypeAny>(options: {
+    client<const TValue, const TSchema extends z.ZodTypeAny>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, TSchema, CollapsedUnion<TSql, TSchema>>>;
-    clientInput<const TValue>(options: {
+    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    client<const TValue>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema?: never;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
-    clientInput<const TSchema extends z.ZodTypeAny>(options: {
+    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
+    client<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"clientInput", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
-    clientInput<const TSchema extends z.ZodTypeAny>(options: {
+    }): Prettify<Builder<"client", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    client<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema | ((tools: any) => TSchema);
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"clientInput", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
-    clientInput<const TValue>(options: {
+    }): Prettify<Builder<"client", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    client<const TValue>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema?: never;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
-    clientInput(options: {
+    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
+    client(options: {
         value?: never;
         schema: (tools: any) => z.ZodTypeAny;
-    }): Prettify<Builder<"clientInput", T, TSql, unknown, z.ZodTypeAny, z.ZodTypeAny>>;
-    clientInput<TClientNext extends z.ZodTypeAny>(schema: ((tools: {
+    }): Prettify<Builder<"client", T, TSql, unknown, z.ZodTypeAny, z.ZodTypeAny>>;
+    client<TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
-    }) => TClientNext) | TClientNext): Prettify<Builder<"clientInput", T, TSql, z.infer<TClientNext>, TClientNext, CollapsedUnion<TSql, TClientNext>>>;
-    client: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
+    }) => TClientNext) | TClientNext): Prettify<Builder<"client", T, TSql, z.infer<TClientNext>, TClientNext, CollapsedUnion<TSql, TClientNext>>>;
+    clientCheck: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
-        clientInput: TClient;
-        client: z.ZodUnion<[TSql, TClient]>;
-    }) => TClientNext) | TClientNext) => Prettify<Builder<"client", T, TSql, TInitialValue, TClient, z.ZodUnion<[TSql, TClientNext]>>>;
+        client: TClient;
+        clientCheck: z.ZodUnion<[TSql, TClient]>;
+    }) => TClientNext) | TClientNext) => Prettify<Builder<"clientCheck", T, TSql, TInitialValue, TClient, z.ZodUnion<[TSql, TClientNext]>>>;
     reference: <TRefSchema extends {
         _tableName: string;
     }>(fieldGetter: () => any) => Builder<"sql", T & {
@@ -114,8 +114,8 @@ export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny,
     }, TSql, TInitialValue, TClient, TValidation>;
     server: <TValidationNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
-        clientInput: TClient;
-        client: z.ZodUnion<[TSql, TClient]>;
+        client: TClient;
+        clientCheck: z.ZodUnion<[TSql, TClient]>;
     }) => TValidationNext) | TValidationNext) => Prettify<Builder<"server", T, TSql, TInitialValue, TClient, TValidationNext>>;
     transform: (transforms: {
         toClient: (dbValue: z.infer<TSql>) => z.infer<TClient>;
@@ -141,12 +141,12 @@ export type RelationConfig<T extends Schema<any>> = (BaseRelationConfig<T> & {
 }) | (BaseRelationConfig<T> & {
     type: "manyToMany";
 });
-type Stage = "sql" | "relation" | "clientInput" | "client" | "server" | "done";
+type Stage = "sql" | "relation" | "client" | "clientCheck" | "server" | "done";
 type StageMethods = {
-    sql: "clientInput" | "client" | "server" | "transform" | "reference";
-    relation: "clientInput" | "client" | "server" | "transform";
-    clientInput: "client" | "server" | "transform";
-    client: "server" | "transform";
+    sql: "client" | "clientCheck" | "server" | "transform" | "reference";
+    relation: "client" | "clientCheck" | "server" | "transform";
+    client: "clientCheck" | "server" | "transform";
+    clientCheck: "server" | "transform";
     server: "transform";
     done: never;
 };
@@ -154,8 +154,8 @@ type BuilderConfig<T extends DbConfig, TSql extends z.ZodTypeAny, TInitialValue,
     sql: T;
     zodSqlSchema: TSql;
     initialValue: TInitialValue;
-    zodClientInputSchema: TClient;
     zodClientSchema: TClient;
+    zodClientCheckedSchema: TClient;
     zodValidationSchema: TValidation;
     clientTransform?: (schema: z.ZodTypeAny) => z.ZodTypeAny;
     validationTransform?: (schema: z.ZodTypeAny) => z.ZodTypeAny;
@@ -165,8 +165,8 @@ export type Builder<TStage extends Stage, T extends DbConfig, TSql extends z.Zod
         sql: T;
         zodSqlSchema: TSql;
         initialValue: TInitialValue;
-        zodClientInputSchema: TClient;
-        zodClientSchema: TValidation;
+        zodClientSchema: TClient;
+        zodClientCheckedSchema: TValidation;
         zodValidationSchema: TValidation;
     };
 } & Pick<IBuilderMethods<T, TSql, TInitialValue, TClient, TValidation>, StageMethods[TStage]>;
@@ -179,28 +179,28 @@ export type Reference<TGetter extends () => any> = {
     getter: TGetter;
 };
 interface ShapeAPI {
-    clientInput<const TValue, const TSchema extends z.ZodTypeAny>(options: {
+    client<const TValue, const TSchema extends z.ZodTypeAny>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
         clientPk?: boolean | ((val: any) => boolean);
-    }): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, TSchema, TSchema>;
-    clientInput<const TValue>(options: {
+    }): Builder<"client", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, TSchema, TSchema>;
+    client<const TValue>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema?: never;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
-    clientInput<const TSchema extends z.ZodTypeAny>(options: {
+    }): Builder<"client", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
+    client<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Builder<"clientInput", null, z.ZodUndefined, z.infer<TSchema>, TSchema, TSchema>;
-    clientInput<const TValue>(value: TValue | ((tools: {
+    }): Builder<"client", null, z.ZodUndefined, z.infer<TSchema>, TSchema, TSchema>;
+    client<const TValue>(value: TValue | ((tools: {
         uuid: () => string;
-    }) => TValue)): Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
+    }) => TValue)): Builder<"client", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
     sqlite: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "sqlite">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     postgres: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "postgres">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     mysql: <const T extends SQLTypeInput>(sqlConfig: T) => Builder<"sql", WithDialect<T, "mysql">, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
@@ -228,15 +228,15 @@ export type RefinementError = {
     path: string[];
     message: string;
 };
-type RefineLayer = "client" | "server" | "sql" | "clientInput" | "all";
+type RefineLayer = "client" | "clientCheck" | "server" | "sql" | "all";
 type RefineEntry = {
     layers: RefineLayer[];
     deps: string[] | null;
     check: (row: any) => RefinementError | RefinementError[] | undefined | null;
 };
 type RefineHelper<T extends ShapeSchema> = {
+    (layer: "clientCheck", check: (row: InferClientCheckedRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
     (layer: "client", check: (row: InferClientRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
-    (layer: "clientInput", check: (row: InferClientInputRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
     (layer: "server", check: (row: InferValidationRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
     (layer: "sql", check: (row: InferSqlRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
     (layer: "all", check: (row: InferClientRow<T>) => RefinementError | RefinementError[] | undefined | null, deps?: string | string[]): RefineEntry;
@@ -267,8 +267,8 @@ type PickDbFieldKeys<T extends ShapeSchema> = {
         type: "hasMany" | "hasOne" | "belongsTo" | "manyToMany";
     } ? never : K : never;
 }[keyof T];
+type InferClientCheckedRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientCheckedSchema">>>>>;
 type InferClientRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientSchema">>>>>;
-type InferClientInputRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientInputSchema">>>>>;
 type InferValidationRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodValidationSchema">>>>>;
 type InferSqlRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodSqlSchema">>>>>;
 type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
@@ -295,7 +295,7 @@ type BaseSchemaField<T extends SQLType = SQLType> = {
     type: "field";
     sql: T;
     zodDbSchema: z.ZodType<any>;
-    zodClientSchema: z.ZodType<any>;
+    zodClientCheckedSchema: z.ZodType<any>;
     defaultValue?: any;
     __fieldId?: string;
     toClient?: (dbValue: any) => any;
@@ -333,17 +333,17 @@ export declare function createSchema<T extends {
     };
     isClientRecord: (record: any) => boolean;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
-    clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientInputSchema">>>;
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
+    clientCheckedSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientCheckedSchema">>>;
     serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
     defaultValues: Prettify<DeriveDefaults<TActualSchema>>;
     stateType: Prettify<DeriveStateType<TActualSchema>>;
     generateDefaults: () => Prettify<DeriveDefaults<TActualSchema>>;
-    toClient: (dbObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>;
-    toDb: (clientObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>;
+    toClient: (dbObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientCheckedSchema">>>>;
+    toDb: (clientObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientCheckedSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>;
     parseForDb: (appData: z.input<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>;
     parsePatchForDb: (patchData: Partial<z.input<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>>>) => Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>;
-    parseFromDb: (dbData: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>;
+    parseFromDb: (dbData: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientCheckedSchema">>>>;
 };
 export type PlaceholderReference = {
     __type: "placeholder-reference";
@@ -397,8 +397,8 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
         rawSchema: ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>;
         zodSchemas: {
             sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodSqlSchema">>>;
-            clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientInputSchema">>>;
             clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientSchema">>>;
+            clientCheckedSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientCheckedSchema">>>;
             serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodValidationSchema">>>;
             defaultValues: Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
             stateType: Prettify<DeriveStateType<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
@@ -442,8 +442,8 @@ type GetRelationRegistryKey<Field, TRegistry extends RegistryShape> = Field exte
 type OmitRelationFields<Shape, RawSchema> = Omit<Shape, {
     [K in keyof Shape]: K extends keyof RawSchema ? IsRelationField<RawSchema[K]> extends true ? K : never : never;
 }[keyof Shape]>;
-type _DeriveViewShape<TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape, TKey extends "clientSchema" | "serverSchema" | "sqlSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : TKey extends "sqlSchema" ? TRegistry[TTableName]["zodSchemas"]["sqlSchema"] extends z.ZodObject<infer BaseShape> ? _DeriveViewShapeInner<BaseShape, TTableName, TSelection, TRegistry, TKey, Depth> : never : TRegistry[TTableName]["zodSchemas"][TKey] extends z.ZodObject<infer BaseShape> ? _DeriveViewShapeInner<BaseShape, TTableName, TSelection, TRegistry, TKey, Depth> : never;
-type _DeriveViewShapeInner<BaseShape, TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape, TKey extends "clientSchema" | "serverSchema" | "sqlSchema", Depth extends any[] = []> = TSelection extends Record<string, any> ? Prettify<OmitRelationFields<BaseShape, TRegistry[TTableName]["rawSchema"]> & {
+type _DeriveViewShape<TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape, TKey extends "clientSchema" | "clientCheckedSchema" | "serverSchema" | "sqlSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : TKey extends "sqlSchema" ? TRegistry[TTableName]["zodSchemas"]["sqlSchema"] extends z.ZodObject<infer BaseShape> ? _DeriveViewShapeInner<BaseShape, TTableName, TSelection, TRegistry, TKey, Depth> : never : TRegistry[TTableName]["zodSchemas"][TKey] extends z.ZodObject<infer BaseShape> ? _DeriveViewShapeInner<BaseShape, TTableName, TSelection, TRegistry, TKey, Depth> : never;
+type _DeriveViewShapeInner<BaseShape, TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape, TKey extends "clientSchema" | "clientCheckedSchema" | "serverSchema" | "sqlSchema", Depth extends any[] = []> = TSelection extends Record<string, any> ? Prettify<OmitRelationFields<BaseShape, TRegistry[TTableName]["rawSchema"]> & {
     [K in keyof TSelection & keyof TRegistry[TTableName]["rawSchema"] as IsRelationField<TRegistry[TTableName]["rawSchema"][K]> extends true ? K : never]: GetRelationRegistryKey<TRegistry[TTableName]["rawSchema"][K], TRegistry> extends infer TargetKey ? TargetKey extends keyof TRegistry ? TRegistry[TTableName]["rawSchema"][K] extends {
         config: {
             sql: {
@@ -508,6 +508,7 @@ export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRe
     schemas: {
         sql: TRegistry[TTableName]["zodSchemas"]["sqlSchema"];
         client: z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>;
+        clientChecked: z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientCheckedSchema">>;
         server: z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "serverSchema">>;
     };
     transforms: {
@@ -556,8 +557,8 @@ type RegistryShape = Record<string, {
     rawSchema: any;
     zodSchemas: {
         sqlSchema: z.ZodObject<any>;
-        clientInputSchema: z.ZodObject<any>;
         clientSchema: z.ZodObject<any>;
+        clientCheckedSchema: z.ZodObject<any>;
         serverSchema: z.ZodObject<any>;
         defaultValues: any;
         stateType: any;
@@ -590,8 +591,8 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
         schemaKey: K;
         schemas: {
             sql: Resolved[K]["zodSchemas"]["sqlSchema"];
-            clientInput: Resolved[K]["zodSchemas"]["clientInputSchema"];
             client: Resolved[K]["zodSchemas"]["clientSchema"];
+            clientChecked: Resolved[K]["zodSchemas"]["clientCheckedSchema"];
             server: Resolved[K]["zodSchemas"]["serverSchema"];
         };
         transforms: {
@@ -636,7 +637,7 @@ type GetDbKey<K, Field> = Field extends Reference<infer TGetter> ? ReturnType<TG
         };
     };
 } ? string extends F ? K : F : K;
-type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientInputSchema" | "zodClientSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
+type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodClientCheckedSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
     [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" | "refine" | "__refines" ? never : K extends keyof T ? T[K] extends {
         config: {
             sql: {