veryfront 0.1.502 → 0.1.504

package/src/src/rendering/orchestrator/html-project-css.ts

@@ -89,7 +89,7 @@ export function startProjectCSSPreparation(
     {
       minify: true,
       environment: htmlOptions.environment,
-      buildMode: htmlOptions.mode,
+      buildMode: htmlOptions.mode as "development" | "production",
     },
   );
 }

package/src/src/rendering/renderer.ts

@@ -298,7 +298,7 @@ export class Renderer {
     if (!url) return slug;
 
     // Get query param handling options from config
-    const queryParamOptions: QueryParamCacheOptions | undefined = ctx.config?.cache?.queryParams;
+    const queryParamOptions = ctx.config?.cache?.queryParams as QueryParamCacheOptions | undefined;
 
     return buildQueryAwareCacheKey(slug, url, queryParamOptions);
   }
@@ -523,7 +523,7 @@ export class Renderer {
       adapter: ctx.adapter,
       mode: ctx.mode,
       projectDir: ctx.projectDir,
-      queryParamOptions: ctx.config?.cache?.queryParams,
+      queryParamOptions: ctx.config?.cache?.queryParams as QueryParamCacheOptions | undefined,
     });
 
     return { pipeline };

package/src/src/repositories/schemas/repository.schema.ts

@@ -1,27 +1,41 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
-export const RepositoryContextSchema = z.object({
-  projectId: z.string(),
-  environment: z.enum(["production", "preview"]),
-  versionId: z.string(),
-});
+export const getRepositoryContextSchema = defineSchema((v) =>
+  v.object({
+    projectId: v.string(),
+    environment: v.enum(["production", "preview"]),
+    versionId: v.string(),
+  })
+);
 
-export const CacheStatsSchema = z.object({
-  gets: z.number().int().nonnegative(),
-  hits: z.number().int().nonnegative(),
-  misses: z.number().int().nonnegative(),
-  sets: z.number().int().nonnegative(),
-  deletes: z.number().int().nonnegative(),
-  hitRate: z.number().min(0).max(1),
-});
+export const getCacheStatsSchema = defineSchema((v) =>
+  v.object({
+    gets: v.number().int().nonnegative(),
+    hits: v.number().int().nonnegative(),
+    misses: v.number().int().nonnegative(),
+    sets: v.number().int().nonnegative(),
+    deletes: v.number().int().nonnegative(),
+    hitRate: v.number().min(0).max(1),
+  })
+);
 
-export const CacheRepositoryOptionsSchema = z.object({
-  name: z.string().optional(),
-  defaultTtlSeconds: z.number().int().positive().optional(),
-  maxEntries: z.number().int().positive().optional(),
-});
+export const getCacheRepositoryOptionsSchema = defineSchema((v) =>
+  v.object({
+    name: v.string().optional(),
+    defaultTtlSeconds: v.number().int().positive().optional(),
+    maxEntries: v.number().int().positive().optional(),
+  })
+);
 
 // Inferred types
-export type RepositoryContext = z.infer<typeof RepositoryContextSchema>;
-export type CacheStats = z.infer<typeof CacheStatsSchema>;
-export type CacheRepositoryOptions = z.infer<typeof CacheRepositoryOptionsSchema>;
+export type RepositoryContext = InferSchema<ReturnType<typeof getRepositoryContextSchema>>;
+export type CacheStats = InferSchema<ReturnType<typeof getCacheStatsSchema>>;
+export type CacheRepositoryOptions = InferSchema<
+  ReturnType<typeof getCacheRepositoryOptionsSchema>
+>;
+
+// Backward compat aliases
+export const RepositoryContextSchema = getRepositoryContextSchema();
+export const CacheStatsSchema = getCacheStatsSchema();
+export const CacheRepositoryOptionsSchema = getCacheRepositoryOptionsSchema();

package/src/src/resource/index.ts

@@ -6,12 +6,16 @@
  * @example
  * ```ts
  * import { resource } from "veryfront/resource";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getParamsSchema = defineSchema((v) =>
+ *   v.object({ section: v.string() })
+ * );
  *
  * const docs = resource({
  *   pattern: "docs/:section",
  *   description: "API documentation",
- *   paramsSchema: z.object({ section: z.string() }),
+ *   paramsSchema: getParamsSchema(),
  *   load: async ({ section }) => {
  *     return { content: await readDocs(section) };
  *   },

package/src/src/resource/schemas/index.ts

@@ -7,6 +7,8 @@
 export {
   type CachePolicy,
   cachePolicySchema,
+  getCachePolicySchema,
+  getMcpConfigSchema,
   type McpConfig,
   McpConfigSchema,
 } from "./resource.schema.js";

package/src/src/resource/schemas/resource.schema.ts

@@ -1,12 +1,21 @@
-import { z } from "zod";
+import { defineSchema } from "../../schemas/index.js";
+import type { InferSchema } from "../../extensions/schema/index.js";
 
-export const cachePolicySchema = z.enum(["no-cache", "cache", "cache-first"]);
+export const getCachePolicySchema = defineSchema((v) =>
+  v.enum(["no-cache", "cache", "cache-first"] as const)
+);
 
-export const McpConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  cachePolicy: cachePolicySchema.optional(),
-});
+export const getMcpConfigSchema = defineSchema((v) =>
+  v.object({
+    enabled: v.boolean().optional(),
+    cachePolicy: getCachePolicySchema().optional(),
+  })
+);
+
+// Backward-compat aliases
+export const cachePolicySchema = getCachePolicySchema();
+export const McpConfigSchema = getMcpConfigSchema();
 
 // Inferred types
-export type CachePolicy = z.infer<typeof cachePolicySchema>;
-export type McpConfig = z.infer<typeof McpConfigSchema>;
+export type CachePolicy = InferSchema<ReturnType<typeof getCachePolicySchema>>;
+export type McpConfig = InferSchema<ReturnType<typeof getMcpConfigSchema>>;

package/src/src/resource/types.ts

@@ -6,7 +6,7 @@
  * @module veryfront/resource
  */
 
-import type { z } from "zod";
+import type { Schema } from "../extensions/schema/index.js";
 
 // Re-export schema-based types
 export type { CachePolicy, McpConfig } from "./schemas/index.js";
@@ -18,7 +18,7 @@ export interface ResourceConfig<TParams = unknown, TData = unknown> {
   pattern?: string;
   description: string;
   title?: string;
-  paramsSchema: z.ZodSchema<TParams>;
+  paramsSchema: Schema<TParams>;
   load: (params: TParams) => Promise<TData> | TData;
   subscribe?: (params: TParams) => AsyncIterable<TData>;
   mcp?: McpConfig;
@@ -29,7 +29,7 @@ export interface Resource<TParams = unknown, TData = unknown> {
   pattern: string;
   description: string;
   title?: string;
-  paramsSchema: z.ZodSchema<TParams>;
+  paramsSchema: Schema<TParams>;
   load: (params: TParams) => Promise<TData>;
   subscribe?: (params: TParams) => AsyncIterable<TData>;
   mcp?: McpConfig;

package/src/src/routing/api/openapi/types.ts

@@ -1,13 +1,13 @@
-import type { z } from "zod";
+import type { Schema } from "../../../extensions/schema/index.js";
 import type { JsonSchema } from "../../../tool/schema/index.js";
 import type { AppRouteHandler } from "../module-loader/types.js";
 
 export const OPENAPI_METADATA = Symbol.for("veryfront.openapi.metadata");
 
 export interface OpenAPIRouteConfig<
-  TParams extends z.ZodTypeAny = z.ZodTypeAny,
-  TQuery extends z.ZodTypeAny = z.ZodTypeAny,
-  TBody extends z.ZodTypeAny = z.ZodTypeAny,
+  TParams extends Schema = Schema,
+  TQuery extends Schema = Schema,
+  TBody extends Schema = Schema,
 > {
   summary?: string;
   description?: string;
@@ -17,7 +17,7 @@ export interface OpenAPIRouteConfig<
   body?: TBody;
   response?: Record<
     number,
-    z.ZodTypeAny | { schema: z.ZodTypeAny; description?: string }
+    Schema | { schema: Schema; description?: string }
   >;
   deprecated?: boolean;
   handler: AppRouteHandler;

package/src/src/sandbox/hosted-tools.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
 import { tool } from "../tool/index.js";
 import type { CommandJob, CommandJobOutput, ExecOptions } from "./sandbox.js";
 import { LazySandbox, type LazySandboxOptions } from "./lazy-sandbox.js";
@@ -120,6 +120,18 @@ export function createHostedSandboxClient(
   };
 }
 
+const getStartCommandJobInputSchema = defineSchema((v) =>
+  v.object({
+    command: v.string().describe("Single shell command to run asynchronously in the sandbox"),
+  })
+);
+
+const getCommandJobIdInputSchema = defineSchema((v) =>
+  v.object({
+    jobId: v.string().describe("Sandbox command job ID"),
+  })
+);
+
 export async function createHostedSandboxTools(
   input: HostedSandboxToolsOptions,
 ): Promise<HostedSandboxToolsResult> {
@@ -131,32 +143,24 @@ export async function createHostedSandboxTools(
     start_command_job: tool({
       description:
         "Start a long-running sandbox command as an async job. Use this instead of bash for durable shell operations.",
-      inputSchema: z.object({
-        command: z.string().describe("Single shell command to run asynchronously in the sandbox"),
-      }),
+      inputSchema: getStartCommandJobInputSchema(),
       execute: async ({ command }) => await sandbox.startCommandJob(command),
     }),
     get_command_job: tool({
       description:
         "Get the current status for an async sandbox command job. Use this for polling while a long-running job is still running.",
-      inputSchema: z.object({
-        jobId: z.string().describe("Sandbox command job ID"),
-      }),
+      inputSchema: getCommandJobIdInputSchema(),
       execute: async ({ jobId }) => await sandbox.getCommandJob(jobId),
     }),
     get_command_job_output: tool({
       description:
         "Get the captured stdout/stderr and terminal metadata for an async sandbox command job. Prefer calling this after the job reaches a terminal state.",
-      inputSchema: z.object({
-        jobId: z.string().describe("Sandbox command job ID"),
-      }),
+      inputSchema: getCommandJobIdInputSchema(),
       execute: async ({ jobId }) => await sandbox.getCommandJobOutput(jobId),
     }),
     cancel_command_job: tool({
       description: "Cancel a running async sandbox command job.",
-      inputSchema: z.object({
-        jobId: z.string().describe("Sandbox command job ID"),
-      }),
+      inputSchema: getCommandJobIdInputSchema(),
       execute: async ({ jobId }) => await sandbox.cancelCommandJob(jobId),
     }),
   };

package/src/src/schemas/common.ts

@@ -1,47 +1,99 @@
-import { z } from "zod";
+/**
+ * Common reusable schemas (email, slug, URL, UUID, pagination, …) expressed
+ * against the `SchemaValidator` contract via `defineSchema`.
+ *
+ * Each schema is a lazy getter. The `CommonSchemas` object exposes them via
+ * property accessors to preserve the existing call shape
+ * (`CommonSchemas.email.parse(x)` continues to work).
+ *
+ * @module schemas/common
+ */
+
+import type { InferSchema, Schema } from "../extensions/schema/index.js";
 import { MAX_URL_LENGTH_FOR_VALIDATION } from "../utils/constants/index.js";
-import { timestamp } from "./primitives.js";
+import { defineSchema } from "./define.js";
+import { getTimestampSchema } from "./primitives.js";
 
 const SLUG_PATTERN = /^[a-z0-9-]+$/;
 const E164_PHONE_NUMBER_PATTERN = /^\+?[1-9]\d{1,14}$/;
 
-export const CommonSchemas = {
-  email: z.string().email().max(255),
-  uuid: z.string().uuid(),
-  slug: z.string().regex(SLUG_PATTERN).min(1).max(100),
-  url: z.string().url().max(MAX_URL_LENGTH_FOR_VALIDATION),
-  phoneNumber: z.string().regex(E164_PHONE_NUMBER_PATTERN),
-
-  pagination: z.object({
-    page: z.coerce.number().int().positive().default(1),
-    limit: z.coerce.number().int().positive().max(100).default(10),
-    sort: z.string().optional(),
-    order: z.enum(["asc", "desc"]).optional(),
-  }),
-
-  dateRange: z
+export const getEmailSchema = defineSchema((v) => v.string().email().max(255));
+export const getUuidSchema = defineSchema((v) => v.string().uuid());
+export const getSlugSchema = defineSchema((v) => v.string().regex(SLUG_PATTERN).min(1).max(100));
+export const getUrlSchema = defineSchema((v) =>
+  v.string().url().max(MAX_URL_LENGTH_FOR_VALIDATION)
+);
+export const getPhoneNumberSchema = defineSchema((v) =>
+  v.string().regex(E164_PHONE_NUMBER_PATTERN)
+);
+
+export const getPaginationSchema = defineSchema((v) =>
+  v.object({
+    page: v.coerce.number().int().positive().default(1),
+    limit: v.coerce.number().int().positive().max(100).default(10),
+    sort: v.string().optional(),
+    order: v.enum(["asc", "desc"]).optional(),
+  })
+);
+
+export const getDateRangeSchema = defineSchema((v) =>
+  v
     .object({
-      from: timestamp,
-      to: timestamp,
+      from: getTimestampSchema(),
+      to: getTimestampSchema(),
     })
-    .refine(({ from, to }) => new Date(from) <= new Date(to), {
+    .refine(({ from, to }: { from: string; to: string }) => new Date(from) <= new Date(to), {
       message: "From date must be before or equal to To date",
-    }),
+    })
+);
 
-  strongPassword: z
+export const getStrongPasswordSchema = defineSchema((v) =>
+  v
     .string()
     .min(8, "Password must be at least 8 characters")
     .regex(/[A-Z]/, "Password must contain at least one uppercase letter")
     .regex(/[a-z]/, "Password must contain at least one lowercase letter")
     .regex(/[0-9]/, "Password must contain at least one number")
-    .regex(/[^A-Za-z0-9]/, "Password must contain at least one special character"),
+    .regex(/[^A-Za-z0-9]/, "Password must contain at least one special character")
+);
+
+/**
+ * Lazy-getter object that preserves the `CommonSchemas.email` call shape.
+ * Each access returns the cached `Schema<T>` (memoized inside `defineSchema`),
+ * so chained calls like `CommonSchemas.email.parse(x)` work as before.
+ */
+export const CommonSchemas = {
+  get email(): Schema<string> {
+    return getEmailSchema();
+  },
+  get uuid(): Schema<string> {
+    return getUuidSchema();
+  },
+  get slug(): Schema<string> {
+    return getSlugSchema();
+  },
+  get url(): Schema<string> {
+    return getUrlSchema();
+  },
+  get phoneNumber(): Schema<string> {
+    return getPhoneNumberSchema();
+  },
+  get pagination(): ReturnType<typeof getPaginationSchema> {
+    return getPaginationSchema();
+  },
+  get dateRange(): ReturnType<typeof getDateRangeSchema> {
+    return getDateRangeSchema();
+  },
+  get strongPassword(): Schema<string> {
+    return getStrongPasswordSchema();
+  },
 };
 
-export type Email = z.infer<typeof CommonSchemas.email>;
-export type Uuid = z.infer<typeof CommonSchemas.uuid>;
-export type Slug = z.infer<typeof CommonSchemas.slug>;
-export type Url = z.infer<typeof CommonSchemas.url>;
-export type PhoneNumber = z.infer<typeof CommonSchemas.phoneNumber>;
-export type Pagination = z.infer<typeof CommonSchemas.pagination>;
-export type DateRange = z.infer<typeof CommonSchemas.dateRange>;
-export type StrongPassword = z.infer<typeof CommonSchemas.strongPassword>;
+export type Email = InferSchema<ReturnType<typeof getEmailSchema>>;
+export type Uuid = InferSchema<ReturnType<typeof getUuidSchema>>;
+export type Slug = InferSchema<ReturnType<typeof getSlugSchema>>;
+export type Url = InferSchema<ReturnType<typeof getUrlSchema>>;
+export type PhoneNumber = InferSchema<ReturnType<typeof getPhoneNumberSchema>>;
+export type Pagination = InferSchema<ReturnType<typeof getPaginationSchema>>;
+export type DateRange = InferSchema<ReturnType<typeof getDateRangeSchema>>;
+export type StrongPassword = InferSchema<ReturnType<typeof getStrongPasswordSchema>>;

package/src/src/schemas/define.ts

@@ -11,15 +11,25 @@
  * @module schemas/define
  */
 
-import { tryResolve } from "../extensions/contracts.js";
+import { register, tryResolve } from "../extensions/contracts.js";
 import type { Schema, SchemaFactory, SchemaValidator } from "../extensions/schema/index.js";
+import { createZodAdapter } from "../../extensions/ext-zod/src/adapter.js";
+
+export function resolveSchemaValidator(): SchemaValidator {
+  const existing = tryResolve<SchemaValidator>("SchemaValidator");
+  if (existing) return existing;
+
+  const fallback = createZodAdapter();
+  register<SchemaValidator>("SchemaValidator", fallback);
+  return fallback;
+}
 
 /**
  * Wrap a schema factory so that it is built lazily on first call.
  *
  * @param factory - Receives a `SchemaValidator` and returns a `Schema<T>`.
  * @returns A zero-arg getter that caches and returns the built schema.
- * @throws Error when no `SchemaValidator` contract is registered.
+ * Installs the default zod-backed validator when no contract is registered.
  *
  * @example
  * ```ts
@@ -34,10 +44,7 @@ export function defineSchema<T>(factory: SchemaFactory<T>): () => Schema<T> {
   let cached: Schema<T> | undefined;
   return () => {
     if (cached) return cached;
-    const v = tryResolve<SchemaValidator>("SchemaValidator");
-    if (!v) {
-      throw new Error("SchemaValidator contract unresolved — install ext-zod");
-    }
+    const v = resolveSchemaValidator();
     cached = factory(v);
     return cached;
   };

package/src/src/schemas/index.ts

@@ -3,23 +3,35 @@
  * pagination) and primitives (file paths, hex colors, semver, timestamps),
  * plus the `defineSchema` lazy-factory helper.
  *
- * Importing this module also registers the default zod-backed
- * `SchemaValidator` adapter so that `defineSchema(...)` works out of the box.
+ * `defineSchema` resolves the `SchemaValidator` contract on first use. The
+ * default zod-backed implementation lives in `@veryfront/ext-zod` and is
+ * registered at app bootstrap by `createBuiltinExtensions()`. Tests that
+ * exercise schemas without going through full bootstrap import
+ * `./_test-setup.ts` to register the adapter directly.
  *
  * @module schemas
  */
 
-import { registerZodAdapter } from "./zod-adapter.js";
-
-// Register the default SchemaValidator implementation once at module load.
-registerZodAdapter();
-
 export { defineSchema } from "./define.js";
 
+export {
+  isOptionalSchema as schemaIsOptional,
+  type JsonSchema,
+  schemaToJsonSchema,
+} from "./json-schema.js";
+
 export {
   CommonSchemas,
   type DateRange,
   type Email,
+  getDateRangeSchema,
+  getEmailSchema,
+  getPaginationSchema,
+  getPhoneNumberSchema,
+  getSlugSchema,
+  getStrongPasswordSchema,
+  getUrlSchema,
+  getUuidSchema,
   type Pagination,
   type PhoneNumber,
   type Slug,
@@ -30,23 +42,23 @@ export {
 
 export {
   type AbsolutePath,
-  absolutePath,
   type FilePath,
-  filePath,
+  getAbsolutePathSchema,
+  getFilePathSchema,
+  getHexColorSchema,
+  getJsonValueSchema,
+  getNonEmptyStringSchema,
+  getNonNegativeIntSchema,
+  getPortNumberSchema,
+  getPositiveIntSchema,
+  getSemverSchema,
+  getTimestampSchema,
   type HexColor,
-  hexColor,
   type JsonValue,
-  jsonValue,
   type NonEmptyString,
-  nonEmptyString,
   type NonNegativeInt,
-  nonNegativeInt,
   type PortNumber,
-  portNumber,
   type PositiveInt,
-  positiveInt,
   type Semver,
-  semver,
   type Timestamp,
-  timestamp,
 } from "./primitives.js";

package/src/src/schemas/json-schema.ts

@@ -0,0 +1,33 @@
+/**
+ * JSON Schema helpers that route through the `SchemaValidator` extension
+ * contract, so core modules can convert opaque `Schema<T>` instances to
+ * JSON Schema documents without importing zod (or any other validator).
+ *
+ * @module schemas/json-schema
+ */
+
+import type { JsonSchema, Schema } from "../extensions/schema/index.js";
+import { resolveSchemaValidator } from "./define.js";
+
+/**
+ * Convert an opaque `Schema<T>` to a JSON Schema document.
+ *
+ * Resolves the registered `SchemaValidator` and delegates to its
+ * `toJsonSchema` implementation. Callers should pass a `Schema<T>` produced
+ * by `defineSchema` or any other contract-aware builder.
+ */
+export function schemaToJsonSchema(schema: Schema<unknown>): JsonSchema {
+  return resolveSchemaValidator().toJsonSchema(schema);
+}
+
+/**
+ * Returns `true` when the schema permits `undefined`.
+ *
+ * Resolves the registered `SchemaValidator` and delegates to its
+ * `isOptional` implementation.
+ */
+export function isOptionalSchema(schema: Schema<unknown>): boolean {
+  return resolveSchemaValidator().isOptional(schema);
+}
+
+export type { JsonSchema };