veryfront 0.1.502 → 0.1.504

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.502",
+  "version": "0.1.504",
   "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/deps/esm.sh/@types/react-dom@19.2.3/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
 
 export {};
 

package/src/deps/esm.sh/@types/{react@19.2.14 → react@19.2.3}/global.d.ts

@@ -18,7 +18,6 @@ interface KeyboardEvent extends Event {}
 interface MouseEvent extends Event {}
 interface TouchEvent extends Event {}
 interface PointerEvent extends Event {}
-interface SubmitEvent extends Event {}
 interface ToggleEvent extends Event {}
 interface TransitionEvent extends Event {}
 interface UIEvent extends Event {}

package/src/deps/esm.sh/@types/{react@19.2.14 → react@19.2.3}/index.d.ts

@@ -16,7 +16,6 @@ type NativeKeyboardEvent = KeyboardEvent;
 type NativeMouseEvent = MouseEvent;
 type NativeTouchEvent = TouchEvent;
 type NativePointerEvent = PointerEvent;
-type NativeSubmitEvent = SubmitEvent;
 type NativeToggleEvent = ToggleEvent;
 type NativeTransitionEvent = TransitionEvent;
 type NativeUIEvent = UIEvent;
@@ -226,20 +225,12 @@ declare namespace React {
 
     type ComponentState = any;
 
-    interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
-
     /**
      * A value which uniquely identifies a node among items in an array.
      *
      * @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
      */
-    type Key =
-        | string
-        | number
-        | bigint
-        | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
-            keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
-        ];
+    type Key = string | number | bigint;
 
     /**
      * @internal The props any component can receive.
@@ -1893,7 +1884,7 @@ declare namespace React {
      *
      * @param callback A synchronous, void callback that will execute as a single, complete React commit.
      *
-     * @see {@link https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks}
+     * @see https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks
      */
     // NOTES
     // - the order of these signatures matters - typescript will check the signatures in source order.
@@ -1935,31 +1926,7 @@ declare namespace React {
         reducer: (state: State, action: Action) => State,
     ): [State, (action: Action) => void];
 
-    interface UntrackedReactPromise<T> extends PromiseLike<T> {
-        status?: void;
-    }
-
-    export interface PendingReactPromise<T> extends PromiseLike<T> {
-        status: "pending";
-    }
-
-    export interface FulfilledReactPromise<T> extends PromiseLike<T> {
-        status: "fulfilled";
-        value: T;
-    }
-
-    export interface RejectedReactPromise<T> extends PromiseLike<T> {
-        status: "rejected";
-        reason: unknown;
-    }
-
-    export type ReactPromise<T> =
-        | UntrackedReactPromise<T>
-        | PendingReactPromise<T>
-        | FulfilledReactPromise<T>
-        | RejectedReactPromise<T>;
-
-    export type Usable<T> = ReactPromise<T> | Context<T>;
+    export type Usable<T> = PromiseLike<T> | Context<T>;
 
     export function use<T>(usable: Usable<T>): T;
 
@@ -2074,28 +2041,15 @@ declare namespace React {
         target: EventTarget & Target;
     }
 
-    /**
-     * @deprecated FormEvent doesn't actually exist.
-     *             You probably meant to use {@link ChangeEvent}, {@link InputEvent}, {@link SubmitEvent}, or just {@link SyntheticEvent} instead
-     *             depending on the event type.
-     */
     interface FormEvent<T = Element> extends SyntheticEvent<T> {
     }
 
     interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
-    /**
-     * change events bubble in React so their target is generally unknown.
-     * Only for form elements we know their target type because form events can't
-     * be nested.
-     * This type exists purely to narrow `target` for form elements. It doesn't
-     * reflect a DOM event. Change events are just fired as standard {@link SyntheticEvent}.
-     */
-    interface ChangeEvent<CurrentTarget = Element, Target = Element> extends SyntheticEvent<CurrentTarget> {
-        // TODO: This is wrong for change event handlers on arbitrary. Should
-        // be EventTarget & Target, but kept for backward compatibility until React 20.
-        target: EventTarget & CurrentTarget;
+    interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
     interface InputEvent<T = Element> extends SyntheticEvent<T, NativeInputEvent> {
@@ -2165,13 +2119,6 @@ declare namespace React {
         shiftKey: boolean;
     }
 
-    interface SubmitEvent<T = Element> extends SyntheticEvent<T, NativeSubmitEvent> {
-        // `submitter` is available in react@canary
-        // submitter: HTMLElement | null;
-        // SubmitEvents are always targetted at HTMLFormElements.
-        target: EventTarget & HTMLFormElement;
-    }
-
     interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
         altKey: boolean;
         changedTouches: TouchList;
@@ -2227,19 +2174,11 @@ declare namespace React {
     type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>;
     type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>;
     type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>;
-    /**
-     * @deprecated FormEventHandler doesn't actually exist.
-     *             You probably meant to use {@link ChangeEventHandler}, {@link InputEventHandler}, {@link SubmitEventHandler}, or just {@link EventHandler} instead
-     *             depending on the event type.
-     */
     type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
-    type ChangeEventHandler<CurrentTarget = Element, Target = Element> = EventHandler<
-        ChangeEvent<CurrentTarget, Target>
-    >;
+    type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
     type InputEventHandler<T = Element> = EventHandler<InputEvent<T>>;
     type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>;
     type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>;
-    type SubmitEventHandler<T = Element> = EventHandler<SubmitEvent<T>>;
     type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>;
     type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>;
     type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>;
@@ -2293,19 +2232,19 @@ declare namespace React {
         onBlur?: FocusEventHandler<T> | undefined;
         onBlurCapture?: FocusEventHandler<T> | undefined;
 
-        // form related Events
-        onChange?: ChangeEventHandler<T> | undefined;
-        onChangeCapture?: ChangeEventHandler<T> | undefined;
+        // Form Events
+        onChange?: FormEventHandler<T> | undefined;
+        onChangeCapture?: FormEventHandler<T> | undefined;
         onBeforeInput?: InputEventHandler<T> | undefined;
-        onBeforeInputCapture?: InputEventHandler<T> | undefined;
-        onInput?: InputEventHandler<T> | undefined;
-        onInputCapture?: InputEventHandler<T> | undefined;
-        onReset?: ReactEventHandler<T> | undefined;
-        onResetCapture?: ReactEventHandler<T> | undefined;
-        onSubmit?: SubmitEventHandler<T> | undefined;
-        onSubmitCapture?: SubmitEventHandler<T> | undefined;
-        onInvalid?: ReactEventHandler<T> | undefined;
-        onInvalidCapture?: ReactEventHandler<T> | undefined;
+        onBeforeInputCapture?: FormEventHandler<T> | undefined;
+        onInput?: FormEventHandler<T> | undefined;
+        onInputCapture?: FormEventHandler<T> | undefined;
+        onReset?: FormEventHandler<T> | undefined;
+        onResetCapture?: FormEventHandler<T> | undefined;
+        onSubmit?: FormEventHandler<T> | undefined;
+        onSubmitCapture?: FormEventHandler<T> | undefined;
+        onInvalid?: FormEventHandler<T> | undefined;
+        onInvalidCapture?: FormEventHandler<T> | undefined;
 
         // Image Events
         onLoad?: ReactEventHandler<T> | undefined;
@@ -2849,7 +2788,7 @@ declare namespace React {
 
         // Living Standard
         /**
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert}
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert
          */
         inert?: boolean | undefined;
         /**
@@ -3312,9 +3251,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         width?: number | string | undefined;
 
-        // No other element dispatching change events can be nested in a <input>
-        // so we know the target will be a HTMLInputElement.
-        onChange?: ChangeEventHandler<T, HTMLInputElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3479,9 +3416,7 @@ declare namespace React {
         required?: boolean | undefined;
         size?: number | undefined;
         value?: string | readonly string[] | number | undefined;
-        // No other element dispatching change events can be nested in a <select>
-        // so we know the target will be a HTMLSelectElement.
-        onChange?: ChangeEventHandler<T, HTMLSelectElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3533,9 +3468,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         wrap?: string | undefined;
 
-        // No other element dispatching change events can be nested in a <textarea>
-        // so we know the target will be a HTMLTextAreaElement.
-        onChange?: ChangeEventHandler<T, HTMLTextAreaElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3607,9 +3540,6 @@ declare namespace React {
         method?: string | undefined;
         min?: number | string | undefined;
         name?: string | undefined;
-        nonce?: string | undefined;
-        part?: string | undefined;
-        slot?: string | undefined;
         style?: CSSProperties | undefined;
         target?: string | undefined;
         type?: string | undefined;
@@ -4127,6 +4057,7 @@ declare namespace React {
          * Captures which component contained the exception, and its ancestors.
          */
         componentStack?: string | null;
+        digest?: string | null;
     }
 
     // Keep in sync with JSX namespace in ./jsx-runtime.d.ts and ./jsx-dev-runtime.d.ts

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
 
 export {};
 

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";