test(compat): move zod-compat tests to zodCompat.test.ts; tighten normalizeRawShapeSchema guard to require ~standard.jsonSchema

Author: felixweinberger

packages/core/src/util/zodCompat.ts

@@ -7,7 +7,7 @@
 import * as z from 'zod/v4';
 
 import type { StandardSchemaV1, StandardSchemaWithJSON } from './standardSchema.js';
-import { isStandardSchema } from './standardSchema.js';
+import { isStandardSchema, isStandardSchemaWithJSON } from './standardSchema.js';
 
 function isZodSchema(v: unknown): v is z.ZodType {
     if (typeof v !== 'object' || v === null) return false;
@@ -45,9 +45,9 @@ export function normalizeRawShapeSchema(
     if (isZodRawShape(schema)) {
         return z.object(schema) as StandardSchemaWithJSON;
     }
-    if (!isStandardSchema(schema)) {
+    if (!isStandardSchemaWithJSON(schema)) {
         throw new TypeError(
-            'inputSchema/outputSchema/argsSchema must be a Standard Schema (e.g. z.object({...})) or a raw Zod shape ({ field: z.string() }).'
+            'inputSchema/outputSchema/argsSchema must be a Standard Schema with JSON Schema export (`~standard.jsonSchema`, e.g. z.object({...}) from zod >=4.2.0) or a raw Zod shape ({ field: z.string() }).'
         );
     }
     return schema;

packages/core/test/util/standardSchema.test.ts

@@ -1,41 +1,6 @@
 import * as z from 'zod/v4';
 
 import { standardSchemaToJsonSchema } from '../../src/util/standardSchema.js';
-import { isZodRawShape, normalizeRawShapeSchema } from '../../src/util/zodCompat.js';
-
-describe('isZodRawShape', () => {
-    test('treats empty object as a raw shape (matches v1)', () => {
-        expect(isZodRawShape({})).toBe(true);
-    });
-    test('detects raw shape with zod fields', () => {
-        expect(isZodRawShape({ a: z.string() })).toBe(true);
-    });
-    test('rejects a Standard Schema instance', () => {
-        expect(isZodRawShape(z.object({ a: z.string() }))).toBe(false);
-    });
-    test('rejects a shape with non-Zod Standard Schema fields', () => {
-        const nonZod = { '~standard': { version: 1, vendor: 'arktype', validate: () => ({ value: 'x' }) } };
-        expect(isZodRawShape({ a: nonZod })).toBe(false);
-    });
-});
-
-describe('normalizeRawShapeSchema', () => {
-    test('wraps empty raw shape into z.object({})', () => {
-        const wrapped = normalizeRawShapeSchema({});
-        expect(wrapped).toBeDefined();
-        expect(standardSchemaToJsonSchema(wrapped!, 'input').type).toBe('object');
-    });
-    test('passes through an already-wrapped Standard Schema unchanged', () => {
-        const schema = z.object({ a: z.string() });
-        expect(normalizeRawShapeSchema(schema)).toBe(schema);
-    });
-    test('returns undefined for undefined input', () => {
-        expect(normalizeRawShapeSchema(undefined)).toBeUndefined();
-    });
-    test('throws TypeError for an invalid object that is neither raw shape nor Standard Schema', () => {
-        expect(() => normalizeRawShapeSchema({ a: 'not a zod schema' } as never)).toThrow(TypeError);
-    });
-});
 
 describe('standardSchemaToJsonSchema', () => {
     test('emits type:object for plain z.object schemas', () => {

packages/core/test/util/zodCompat.test.ts

@@ -0,0 +1,42 @@
+import * as z from 'zod/v4';
+
+import { standardSchemaToJsonSchema } from '../../src/util/standardSchema.js';
+import { isZodRawShape, normalizeRawShapeSchema } from '../../src/util/zodCompat.js';
+
+describe('isZodRawShape', () => {
+    test('treats empty object as a raw shape (matches v1)', () => {
+        expect(isZodRawShape({})).toBe(true);
+    });
+    test('detects raw shape with zod fields', () => {
+        expect(isZodRawShape({ a: z.string() })).toBe(true);
+    });
+    test('rejects a Standard Schema instance', () => {
+        expect(isZodRawShape(z.object({ a: z.string() }))).toBe(false);
+    });
+    test('rejects a shape with non-Zod Standard Schema fields', () => {
+        const nonZod = { '~standard': { version: 1, vendor: 'arktype', validate: () => ({ value: 'x' }) } };
+        expect(isZodRawShape({ a: nonZod })).toBe(false);
+    });
+});
+
+describe('normalizeRawShapeSchema', () => {
+    test('wraps empty raw shape into z.object({})', () => {
+        const wrapped = normalizeRawShapeSchema({});
+        expect(wrapped).toBeDefined();
+        expect(standardSchemaToJsonSchema(wrapped!, 'input').type).toBe('object');
+    });
+    test('passes through an already-wrapped Standard Schema unchanged', () => {
+        const schema = z.object({ a: z.string() });
+        expect(normalizeRawShapeSchema(schema)).toBe(schema);
+    });
+    test('returns undefined for undefined input', () => {
+        expect(normalizeRawShapeSchema(undefined)).toBeUndefined();
+    });
+    test('throws TypeError for an invalid object that is neither raw shape nor Standard Schema', () => {
+        expect(() => normalizeRawShapeSchema({ a: 'not a zod schema' } as never)).toThrow(TypeError);
+    });
+    test('throws TypeError for a Standard Schema without JSON Schema export', () => {
+        const noJson = { '~standard': { version: 1, vendor: 'x', validate: () => ({ value: {} }) } };
+        expect(() => normalizeRawShapeSchema(noJson as never)).toThrow(/~standard\.jsonSchema/);
+    });
+});