veryfront 0.1.501 → 0.1.503

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.501",
+  "version": "0.1.503",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "workspace": [
@@ -15,7 +15,8 @@ export default {
     "./extensions/ext-node-compatibility",
     "./extensions/ext-parser-babel",
     "./extensions/ext-tracing-opentelemetry",
-    "./extensions/ext-transform-mdx"
+    "./extensions/ext-transform-mdx",
+    "./extensions/ext-zod"
   ],
   "exclude": [
     "npm/",
@@ -286,9 +287,13 @@ export default {
     "@babel/parser": "npm:@babel/parser@7.29.2",
     "gray-matter": "npm:gray-matter@4.0.3",
     "zod": "npm:zod@4.3.6",
+    "mdast": "npm:@types/mdast@4.0.3",
+    "hast": "npm:@types/hast@3.0.3",
+    "unist": "npm:@types/unist@3.0.2",
     "unified": "npm:unified@11.0.5",
     "class-variance-authority": "npm:class-variance-authority@0.7.1",
     "tailwind-merge": "npm:tailwind-merge@3.5.0",
+    "veryfront/schemas": "./src/schemas/index.ts",
     "veryfront/chat/conversation": "./src/chat/conversation.ts",
     "veryfront/chat/message-prep": "./src/chat/message-prep.ts",
     "veryfront/chat/final-step-fallback": "./src/chat/final-step-fallback.ts",
@@ -341,13 +346,14 @@ export default {
     "fmt": "deno fmt src/ cli/",
     "fmt:check": "deno fmt --check src/ cli/",
     "typecheck": "deno task generate && deno check src/index.ts cli/main.ts src/server/index.ts src/routing/api/index.ts src/rendering/index.ts src/platform/index.ts src/platform/adapters/index.ts src/build/index.ts src/build/production-build/index.ts src/transforms/index.ts src/config/index.ts src/utils/index.ts src/data/index.ts src/security/index.ts src/middleware/index.ts src/server/handlers/dev/index.ts src/server/handlers/request/api/index.ts src/rendering/cache/index.ts src/rendering/cache/stores/index.ts src/rendering/rsc/actions/index.ts src/html/index.ts src/modules/index.ts src/proxy/main.ts src/chat/index.ts src/markdown/index.ts src/mdx/index.ts src/fs/index.ts src/oauth/index.ts src/agent/index.ts src/agent/agent-service-route-export.check.ts src/tool/index.ts src/workflow/index.ts src/prompt/index.ts src/resource/index.ts src/jobs/index.ts src/mcp/index.ts src/provider/index.ts",
-    "verify": "deno task generate && deno fmt --check src/ cli/ && DENO_NO_PACKAGE_JSON=1 deno lint src/ cli/ && deno task lint:style && deno task lint:cli-boundary && deno task lint:wildcard-exports && deno task lint:barrel-jsdoc && deno task docs:validate && deno task typecheck && deno task test && deno task test:e2e:binary",
-    "verify:quick": "deno task generate && deno fmt --check src/ cli/ && DENO_NO_PACKAGE_JSON=1 deno lint src/ cli/ && deno task lint:style && deno task lint:cli-boundary && deno task lint:wildcard-exports && deno task lint:barrel-jsdoc && deno task docs:validate && deno task typecheck",
+    "verify": "deno task generate && deno fmt --check src/ cli/ && DENO_NO_PACKAGE_JSON=1 deno lint src/ cli/ && deno task lint:style && deno task lint:cli-boundary && deno task lint:wildcard-exports && deno task lint:barrel-jsdoc && deno task lint:ban-zod && deno task docs:validate && deno task typecheck && deno task test && deno task test:e2e:binary",
+    "verify:quick": "deno task generate && deno fmt --check src/ cli/ && DENO_NO_PACKAGE_JSON=1 deno lint src/ cli/ && deno task lint:style && deno task lint:cli-boundary && deno task lint:wildcard-exports && deno task lint:barrel-jsdoc && deno task lint:ban-zod && deno task docs:validate && deno task typecheck",
     "docs": "rm -rf docs/reference && deno run --allow-read --allow-write --allow-run scripts/docs/generate-api-reference.ts",
     "docs:copy": "rm -rf ../../docs/docs/code/reference && cp -r docs/reference/ ../../docs/docs/code/reference/",
     "docs:validate": "deno run --allow-read scripts/docs/validate-api-reference.ts",
     "docs:verify-npm": "node scripts/docs/verify-npm-exports.mjs && node scripts/docs/verify-npm-node.mjs",
     "docs:check-links": "deno run -A scripts/lint/check-doc-links.ts",
+    "lint:ban-zod": "deno run --allow-read scripts/lint/ban-zod-imports.ts",
     "lint:ban-console": "deno run --allow-read scripts/lint/ban-console.ts",
     "lint:ban-deep-imports": "deno run --allow-read scripts/lint/ban-deep-imports.ts",
     "lint:imports": "deno run --allow-read scripts/lint/no-cross-boundary-relative-imports.ts",

package/src/extensions/ext-zod/src/adapter.ts

@@ -0,0 +1,238 @@
+/**
+ * Zod-backed `SchemaValidator` adapter.
+ *
+ * The default implementation of the `SchemaValidator` contract. It thinly
+ * wraps zod so that core modules can declare schemas through the
+ * extension-neutral DSL while still getting zod's runtime behavior.
+ *
+ * The entire zod surface used by the contract is confined to this file.
+ *
+ * @module extensions/ext-zod/adapter
+ */
+
+import { z } from "zod";
+import type {
+  InferShape,
+  JsonSchema,
+  RefinementCtx,
+  Schema,
+  SchemaValidator,
+  SchemaValidatorCoerce,
+  ValidationIssue,
+  ValidationResult,
+} from "../../../src/extensions/schema/index.js";
+import { isOptionalSchema, zodToJsonSchema } from "./json-schema.js";
+
+// deno-lint-ignore no-explicit-any -- zod's chainable APIs return parametric types
+type AnyZodSchema = z.ZodType<any, any, any>;
+
+/** Unwrap our opaque Schema<T> back to the underlying zod schema. */
+function toZod<T>(schema: Schema<T>): AnyZodSchema {
+  return (schema as unknown as { __zod: AnyZodSchema }).__zod;
+}
+
+/** Wrap a zod schema as an opaque Schema<T> with chainables routed through zod. */
+function wrap<T>(zs: AnyZodSchema): Schema<T> {
+  // The wrapper fakes the full Schema<T> surface; unsupported chainables on
+  // unsuitable kinds (e.g. calling `.email()` on a number) throw at runtime
+  // just like zod would.
+  // deno-lint-ignore no-explicit-any -- safe within this adapter
+  const anyZs = zs as any;
+  const s: Schema<T> = {
+    _output: undefined as unknown as T,
+    optional: () => wrap<T | undefined>(zs.optional()),
+    nullable: () => wrap<T | null>(zs.nullable()),
+    nullish: () => wrap<T | null | undefined>(zs.nullish()),
+    default: (value: Exclude<T, undefined> | (() => Exclude<T, undefined>)) =>
+      wrap<Exclude<T, undefined>>(anyZs.default(value)),
+    describe: (description: string) => wrap<T>(zs.describe(description)),
+    refine: (
+      check: (value: T) => boolean,
+      message?: string | { message?: string },
+    ) => wrap<T>(zs.refine(check as (v: unknown) => boolean, message as never)),
+    superRefine: (check: (value: T, ctx: RefinementCtx) => void) =>
+      wrap<T>(
+        // zod v4's `RefinementCtx` extends `ParsePayload` (`{ value, issues }`)
+        // and exposes `addIssue(string | $ZodSuperRefineIssue)`. We bridge to
+        // our path-aware `RefinementCtx` shape: we don't have a stable `path`
+        // from the zod side here (path tracking is per-issue, not per-ctx),
+        // so we emit `[]` and let callers pass their own `path` through
+        // `addIssue({ path })`.
+        anyZs.superRefine((value: T, zodCtx: { addIssue: (arg: unknown) => void }) => {
+          const ctx: RefinementCtx = {
+            path: [],
+            addIssue: (issue) =>
+              zodCtx.addIssue({
+                // String literal "custom" replaces the deprecated
+                // z.ZodIssueCode.custom enum (zod v4 prefers raw codes).
+                code: issue.code ?? "custom",
+                message: issue.message,
+                path: issue.path,
+              }),
+          };
+          check(value, ctx);
+        }),
+      ),
+    transform: <U>(fn: (value: T) => U) => wrap<U>(zs.transform(fn as never)),
+    strict: () => wrap<T>(anyZs.strict()),
+    strip: () => wrap<T>(anyZs.strip()),
+    passthrough: () => wrap<T & Record<string, unknown>>(anyZs.passthrough()),
+    partial: () => wrap<Partial<T>>(anyZs.partial()),
+    extend: <U extends Record<string, Schema<unknown>>>(shape: U) => {
+      const zodShape = toZodShape(shape);
+      return wrap<T & { [K in keyof U]: U[K] extends Schema<infer V> ? V : never }>(
+        anyZs.extend(zodShape),
+      );
+    },
+    merge: <U>(other: Schema<U>) => wrap<T & U>(anyZs.merge(toZod(other))),
+    omit: <K extends keyof T>(keys: { [P in K]?: true }) => wrap<Omit<T, K>>(anyZs.omit(keys)),
+    pick: <K extends keyof T>(keys: { [P in K]?: true }) => wrap<Pick<T, K>>(anyZs.pick(keys)),
+    min: (value: number, message?: string) => wrap<T>(anyZs.min(value, message)),
+    max: (value: number, message?: string) => wrap<T>(anyZs.max(value, message)),
+    int: (message?: string) => wrap<T>(anyZs.int(message)),
+    positive: (message?: string) => wrap<T>(anyZs.positive(message)),
+    nonnegative: (message?: string) => wrap<T>(anyZs.nonnegative(message)),
+    regex: (pattern: RegExp, message?: string) => wrap<T>(anyZs.regex(pattern, message)),
+    email: (message?: string) => wrap<T>(anyZs.email(message)),
+    url: (message?: string) => wrap<T>(anyZs.url(message)),
+    uuid: (message?: string) => wrap<T>(anyZs.uuid(message)),
+    datetime: (message?: string) => wrap<T>(anyZs.datetime(message)),
+    pipe: <U>(next: Schema<U>): Schema<U> => wrap<U>(zs.pipe(toZod(next))),
+    parse: (data: unknown): T => zs.parse(data) as T,
+    safeParse: (data: unknown): ValidationResult<T> => {
+      const res = zs.safeParse(data);
+      if (res.success) return { success: true, data: res.data as T };
+      const issues: ValidationIssue[] = res.error.issues.map((issue) => ({
+        path: issue.path as (string | number)[],
+        message: issue.message,
+        code: issue.code,
+      }));
+      return { success: false, issues, error: res.error };
+    },
+  };
+  // Attach the underlying zod schema for adapter round-trips without
+  // widening the public Schema<T> surface.
+  (s as unknown as { __zod: AnyZodSchema }).__zod = zs;
+  return s;
+}
+
+function toZodShape(
+  shape: Record<string, Schema<unknown>>,
+): Record<string, AnyZodSchema> {
+  const out: Record<string, AnyZodSchema> = {};
+  for (const [key, value] of Object.entries(shape)) {
+    out[key] = toZod(value);
+  }
+  return out;
+}
+
+const coerce: SchemaValidatorCoerce = {
+  string: (): Schema<string> => wrap(z.coerce.string()),
+  number: (): Schema<number> => wrap(z.coerce.number()),
+  boolean: (): Schema<boolean> => wrap(z.coerce.boolean()),
+  date: (): Schema<Date> => wrap(z.coerce.date()),
+};
+
+/**
+ * Build a zod-backed `SchemaValidator` instance.
+ *
+ * Stateless — safe to call once at extension setup and pass the returned
+ * value to `ctx.provide("SchemaValidator", …)`. Tests that need to register
+ * the validator without going through full extension bootstrap can call this
+ * factory directly.
+ */
+export function createZodAdapter(): SchemaValidator {
+  return {
+    string: (): Schema<string> => wrap(z.string()),
+    number: (): Schema<number> => wrap(z.number()),
+    boolean: (): Schema<boolean> => wrap(z.boolean()),
+    date: (): Schema<Date> => wrap(z.date()),
+    null: (): Schema<null> => wrap(z.null()),
+    unknown: (): Schema<unknown> => wrap(z.unknown()),
+    bigint: (): Schema<bigint> => wrap(z.bigint()),
+    // deno-lint-ignore no-explicit-any -- contract mirrors zod's `any` constructor
+    any: (): Schema<any> => wrap(z.any()),
+    function: (): Schema<(...args: unknown[]) => unknown> =>
+      // zod 4's z.function() is callable without args/returns and produces a
+      // schema accepting any function. We wrap it as Schema<AnyFunction>.
+      wrap(z.function() as unknown as AnyZodSchema),
+
+    object: <S extends Record<string, Schema<unknown>>>(shape: S): Schema<InferShape<S>> =>
+      wrap(z.object(toZodShape(shape))),
+
+    array: <T>(element: Schema<T>): Schema<T[]> => wrap(z.array(toZod(element))),
+
+    tuple: <T extends readonly Schema<unknown>[]>(
+      items: T,
+    ): Schema<{ [K in keyof T]: T[K] extends Schema<infer U> ? U : never }> => {
+      const zodItems = items.map((s) => toZod(s)) as unknown as [
+        AnyZodSchema,
+        ...AnyZodSchema[],
+      ];
+      return wrap(z.tuple(zodItems));
+    },
+
+    record: <K extends string | number | symbol, V>(
+      keys: Schema<K>,
+      values: Schema<V>,
+    ): Schema<Record<K, V>> => wrap(z.record(toZod(keys) as unknown as z.ZodString, toZod(values))),
+
+    union: <T extends readonly [Schema<unknown>, ...Schema<unknown>[]]>(
+      schemas: T,
+    ): Schema<T[number] extends Schema<infer U> ? U : never> => {
+      const zodSchemas = schemas.map((s: Schema<unknown>) => toZod(s)) as unknown as [
+        AnyZodSchema,
+        AnyZodSchema,
+        ...AnyZodSchema[],
+      ];
+      return wrap(z.union(zodSchemas));
+    },
+
+    discriminatedUnion: <
+      K extends string,
+      T extends readonly [Schema<unknown>, ...Schema<unknown>[]],
+    >(
+      discriminator: K,
+      schemas: T,
+    ): Schema<T[number] extends Schema<infer U> ? U : never> => {
+      const zodSchemas = schemas.map((s: Schema<unknown>) => toZod(s)) as unknown as [
+        // deno-lint-ignore no-explicit-any -- discriminated-union variants widen here
+        z.ZodObject<any>,
+        // deno-lint-ignore no-explicit-any -- discriminated-union variants widen here
+        z.ZodObject<any>,
+        // deno-lint-ignore no-explicit-any -- discriminated-union variants widen here
+        ...z.ZodObject<any>[],
+      ];
+      return wrap(z.discriminatedUnion(discriminator, zodSchemas));
+    },
+
+    literal: <T extends string | number | boolean | null>(value: T): Schema<T> =>
+      wrap(z.literal(value as never)),
+
+    enum: <T extends readonly [string, ...string[]]>(values: T): Schema<T[number]> =>
+      wrap(
+        (z.enum as unknown as (v: readonly [string, ...string[]]) => AnyZodSchema)(values),
+      ),
+
+    lazy: <T>(factory: () => Schema<T>): Schema<T> => wrap<T>(z.lazy(() => toZod(factory()))),
+
+    instanceof: <T>(ctor: new (...args: never[]) => T): Schema<T> =>
+      // zod 4's z.instanceof expects `typeof Class` (z.core.util.Class). Our
+      // contract uses a slimmer `new`-able shape; bridge with a single cast
+      // through unknown.
+      wrap<T>(
+        (z.instanceof as unknown as (c: unknown) => AnyZodSchema)(ctor),
+      ),
+
+    custom: <T>(check?: (value: unknown) => boolean, message?: string): Schema<T> =>
+      wrap<T>(z.custom<T>(check as (v: unknown) => boolean, message)),
+
+    coerce,
+
+    validate: <T>(schema: Schema<T>, data: unknown): ValidationResult<T> => schema.safeParse(data),
+
+    toJsonSchema: (schema: Schema<unknown>): JsonSchema => zodToJsonSchema(toZod(schema)),
+
+    isOptional: (schema: Schema<unknown>): boolean => isOptionalSchema(toZod(schema)),
+  };
+}

package/src/extensions/ext-zod/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * ext-zod — SchemaValidator implementation backed by zod.
+ *
+ * Provides the `SchemaValidator` contract via a zod-backed adapter. Core
+ * modules declare schemas through `defineSchema((v) => …)` (in
+ * `src/schemas/define.ts`); the lazy factory resolves this contract on first
+ * use and the adapter routes calls into zod.
+ *
+ * Registered automatically by `createBuiltinExtensions()`. Tests that need
+ * the adapter without going through full extension bootstrap can import
+ * `createZodAdapter` directly from this module's `./adapter.ts`.
+ *
+ * @module extensions/ext-zod
+ */
+
+import type { ExtensionFactory } from "../../../src/extensions/index.js";
+import { createZodAdapter } from "./adapter.js";
+
+const extZod: ExtensionFactory = () => {
+  const impl = createZodAdapter();
+  return {
+    name: "ext-zod",
+    version: "0.1.0",
+    capabilities: [{ type: "contract", name: "SchemaValidator" }],
+    setup(ctx) {
+      ctx.provide("SchemaValidator", impl);
+      ctx.logger.info("[ext-zod] SchemaValidator registered");
+    },
+    teardown() {
+      // No resources to release.
+    },
+  };
+};
+
+export default extZod;
+export { createZodAdapter } from "./adapter.js";

package/src/extensions/ext-zod/src/json-schema.ts

@@ -0,0 +1,311 @@
+/**
+ * Zod-to-JSON-Schema converter used by the `SchemaValidator` adapter.
+ *
+ * Operates directly on zod's internal `_def` shape (covers both v3 and v4)
+ * because zod ships no first-class JSON-Schema export. Confined to
+ * `extensions/ext-zod/` so the rest of the codebase never has to import zod
+ * to learn what a tool's input schema looks like.
+ *
+ * @module extensions/ext-zod/json-schema
+ */
+
+import type { z } from "zod";
+import type { JsonSchema } from "../../../src/extensions/schema/index.js";
+
+/** Zod internal _def shape — covers fields from both v3 and v4. */
+interface ZodDef {
+  typeName?: string; // v3
+  type?: string; // v4
+  value?: unknown; // v3 literal
+  values?: unknown; // v3 enum / v4 literal
+  entries?: Record<string, unknown>; // v4 enum
+  description?: string; // v3 description metadata
+  shape?: (() => Record<string, z.ZodTypeAny>) | Record<string, z.ZodTypeAny>;
+  element?: z.ZodTypeAny; // v4 array/record
+  items?: z.ZodTypeAny[]; // tuple
+  options?: z.ZodTypeAny[] | Map<string, z.ZodTypeAny>; // union
+  valueType?: z.ZodTypeAny; // record
+  catchall?: z.ZodTypeAny; // object unknown-key policy / catchall
+  unknownKeys?: "strip" | "passthrough" | "strict"; // v3 object unknown-key policy
+  innerType?: z.ZodTypeAny; // optional/nullable/default (v3)
+  schema?: z.ZodTypeAny; // effects/optional/nullable (v3/v4)
+  in?: z.ZodTypeAny; // pipe input (v4)
+  getter?: () => z.ZodTypeAny; // lazy
+  defaultValue?: (() => unknown) | unknown;
+}
+
+interface ConversionContext {
+  seen: WeakSet<object>;
+}
+
+const LITERAL_TYPE_MAP: Record<string, "string" | "number" | "boolean"> = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+};
+
+function getLiteralType(value: unknown): "string" | "number" | "boolean" | undefined {
+  return LITERAL_TYPE_MAP[typeof value];
+}
+
+function getDef(schema: z.ZodTypeAny): ZodDef {
+  return schema._def as ZodDef;
+}
+
+/** Get the internal type tag from a zod schema (_def.typeName in v3, _def.type in v4). */
+function getTypeTag(schema: z.ZodTypeAny): string | undefined {
+  const def = getDef(schema);
+  return def.typeName ?? def.type;
+}
+
+export function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema {
+  return convertSchema(schema, { seen: new WeakSet() });
+}
+
+function convertSchema(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  // Guard against invalid schemas (can happen with different zod instances in npm bundle)
+  if (!schema || typeof schema !== "object" || !("_def" in schema)) {
+    throw new Error("Invalid Zod schema: missing _def property");
+  }
+
+  const { schema: unwrapped, nullable } = unwrapSchema(schema);
+  const json = convert(unwrapped, context);
+  const description = getDescription(schema) ?? getDescription(unwrapped);
+  if (description && json.description === undefined) json.description = description;
+
+  return nullable ? { anyOf: [json, { type: "null" }] } : json;
+}
+
+export function isOptionalSchema(schema: z.ZodTypeAny): boolean {
+  return unwrapSchema(schema).optional || hasDefaultSchema(schema);
+}
+
+function convert(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  if (context.seen.has(schema)) return {};
+  context.seen.add(schema);
+
+  try {
+    return convertInner(schema, context);
+  } finally {
+    context.seen.delete(schema);
+  }
+}
+
+function convertInner(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  const tag = getTypeTag(schema);
+  const def = getDef(schema);
+
+  switch (tag) {
+    case "ZodString":
+    case "string":
+      return { type: "string" };
+
+    case "ZodNumber":
+    case "number":
+      return { type: "number" };
+
+    case "ZodBoolean":
+    case "boolean":
+      return { type: "boolean" };
+
+    case "ZodBigInt":
+    case "bigint":
+      return { type: "integer" };
+
+    case "ZodLiteral":
+    case "literal": {
+      // v3: _def.value, v4: _def.values (array of accepted values)
+      const literal = def.value ?? (Array.isArray(def.values) ? def.values[0] : def.values);
+      return { const: literal, type: getLiteralType(literal) };
+    }
+
+    case "ZodEnum":
+    case "ZodNativeEnum":
+    case "enum": {
+      // v3: _def.values (array), v4: _def.entries (object {key: value})
+      const values = def.values ?? (def.entries ? Object.values(def.entries) : []);
+      if (Array.isArray(values)) {
+        return { type: "string", enum: values };
+      }
+      // Native enum: filter out reverse-mapped numeric keys
+      return {
+        enum: Object.values(values).filter((value) => typeof value !== "number"),
+      };
+    }
+
+    case "ZodObject":
+    case "object": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      const properties: Record<string, JsonSchema> = {};
+      const required: string[] = [];
+
+      for (const [key, value] of Object.entries(shape ?? {})) {
+        const zodSchema = value as z.ZodTypeAny;
+        properties[key] = convertSchema(zodSchema, context);
+        if (!isOptionalSchema(zodSchema)) required.push(key);
+      }
+
+      const json: JsonSchema = { type: "object", properties };
+      if (required.length) json.required = required;
+      const additionalProperties = getObjectAdditionalProperties(def, context);
+      if (additionalProperties !== undefined) json.additionalProperties = additionalProperties;
+
+      return json;
+    }
+
+    case "ZodArray":
+    case "array": {
+      // v3: _def.type (item schema), v4: _def.element (item schema)
+      const itemType = def.element ?? (def.type as unknown as z.ZodTypeAny | undefined);
+      if (!itemType || typeof itemType === "string") return { type: "array" };
+      return { type: "array", items: convertSchema(itemType, context) };
+    }
+
+    case "ZodTuple":
+    case "tuple": {
+      const items = def.items ?? [];
+      return {
+        type: "array",
+        prefixItems: items.map((item: z.ZodTypeAny) => convertSchema(item, context)),
+        minItems: items.length,
+        maxItems: items.length,
+      };
+    }
+
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion":
+    case "union": {
+      const options = def.options ?? [];
+      const optionArray = options instanceof Map ? Array.from(options.values()) : options;
+      return { anyOf: optionArray.map((option: z.ZodTypeAny) => convertSchema(option, context)) };
+    }
+
+    case "ZodRecord":
+    case "record": {
+      const valueSchema = def.valueType ?? def.element;
+      if (!valueSchema) return { type: "object" };
+      return { type: "object", additionalProperties: convertSchema(valueSchema, context) };
+    }
+
+    case "ZodDefault":
+    case "default": {
+      const innerType = def.innerType ?? def.schema;
+      if (!innerType) return { type: "object" };
+      const inner = convertSchema(innerType, context);
+      const defaultValue = typeof def.defaultValue === "function"
+        ? def.defaultValue()
+        : def.defaultValue;
+
+      if (typeof inner === "object" && !("anyOf" in inner) && defaultValue !== undefined) {
+        inner.default = defaultValue;
+      }
+
+      return inner;
+    }
+
+    case "ZodLazy":
+    case "lazy":
+      return def.getter ? convert(def.getter(), context) : { type: "object" };
+
+    case "ZodEffects":
+    case "pipe": {
+      // v3: ZodEffects wraps schema in _def.schema
+      // v4: pipe wraps in _def.in (input schema)
+      const innerSchema = def.schema ?? def.in;
+      return innerSchema ? convert(innerSchema, context) : { type: "object" };
+    }
+
+    default:
+      return { type: "object" };
+  }
+}
+
+function getObjectAdditionalProperties(
+  def: ZodDef,
+  context: ConversionContext,
+): boolean | JsonSchema | undefined {
+  if (def.unknownKeys === "passthrough") return true;
+  if (def.unknownKeys === "strict") return false;
+  if (def.unknownKeys === "strip") return undefined;
+
+  if (!def.catchall) return undefined;
+
+  const catchallTag = getTypeTag(def.catchall);
+  if (catchallTag === "unknown" || catchallTag === "ZodUnknown") return true;
+  if (catchallTag === "never" || catchallTag === "ZodNever") return false;
+  return convertSchema(def.catchall, context);
+}
+
+function unwrapSchema(
+  schema: z.ZodTypeAny,
+): { schema: z.ZodTypeAny; nullable: boolean; optional: boolean } {
+  let current: z.ZodTypeAny = schema;
+  let nullable = false;
+  let optional = false;
+
+  while (true) {
+    const tag = getTypeTag(current);
+    const def = getDef(current);
+
+    switch (tag) {
+      case "ZodNullable":
+      case "nullable":
+        nullable = true;
+        current = (def.innerType ?? def.schema)!;
+        break;
+
+      case "ZodOptional":
+      case "optional":
+        optional = true;
+        current = (def.innerType ?? def.schema)!;
+        break;
+
+      case "ZodEffects":
+      case "pipe":
+        current = def.schema ?? def.in ?? current;
+        if (current === schema) return { schema: current, nullable, optional };
+        break;
+
+      default:
+        return { schema: current, nullable, optional };
+    }
+  }
+}
+
+function hasDefaultSchema(schema: z.ZodTypeAny): boolean {
+  let current: z.ZodTypeAny = schema;
+
+  while (true) {
+    const tag = getTypeTag(current);
+    const def = getDef(current);
+
+    switch (tag) {
+      case "ZodDefault":
+      case "default":
+        return true;
+
+      case "ZodNullable":
+      case "nullable":
+      case "ZodOptional":
+      case "optional":
+      case "ZodEffects":
+      case "pipe": {
+        const inner = def.innerType ?? def.schema ?? def.in;
+        if (!inner || inner === current) return false;
+        current = inner;
+        break;
+      }
+
+      default:
+        return false;
+    }
+  }
+}
+
+function getDescription(schema: z.ZodTypeAny): string | undefined {
+  const direct = (schema as { description?: unknown }).description;
+  if (typeof direct === "string") return direct;
+
+  const defDescription = getDef(schema).description;
+  return typeof defDescription === "string" ? defDescription : undefined;
+}