veryfront 0.1.519 → 0.1.521

package/src/src/jobs/schemas.ts

@@ -1,4 +1,4 @@
-import { defineSchema } from "../schemas/index.js";
+import { defineSchema, lazySchema } from "../schemas/index.js";
 import type { InferSchema, SchemaValidator } from "../extensions/schema/index.js";
 
 export const getJobStatusSchema = defineSchema((v) =>
@@ -334,35 +334,44 @@ export const getPaginatedCronJobsResponseSchema = defineSchema((v) =>
 );
 
 // Backward-compat aliases
-export const JobStatusSchema = getJobStatusSchema();
-export const CronJobStatusSchema = getCronJobStatusSchema();
-export const JobKindSchema = getJobKindSchema();
-export const ReservedJobTargetFamilySchema = getReservedJobTargetFamilySchema();
-export const PageInfoSchema = getPageInfoSchema();
-export const KnowledgeIngestFileResultSchema = getKnowledgeIngestFileResultSchema();
-export const KnowledgeIngestSkippedFileResultSchema = getKnowledgeIngestSkippedFileResultSchema();
-export const KnowledgeIngestFailedFileResultSchema = getKnowledgeIngestFailedFileResultSchema();
-export const KnowledgeIngestJobResultMetadataSchema = getKnowledgeIngestJobResultMetadataSchema();
-export const KnowledgeIngestJobResultCountsSchema = getKnowledgeIngestJobResultCountsSchema();
-export const KnowledgeIngestJobResultSchema = getKnowledgeIngestJobResultSchema();
-export const JobResultSchema = getJobResultSchema();
-export const JobResultSummarySchema = getJobResultSummarySchema();
-export const JobSchema = getJobSchema();
-export const JobListItemSchema = getJobListItemSchema();
-export const PaginatedJobsResponseSchema = getPaginatedJobsResponseSchema();
-export const JobEventSchema = getJobEventSchema();
-export const JobEventsResponseSchema = getJobEventsResponseSchema();
-export const JobLogsResponseSchema = getJobLogsResponseSchema();
-export const KnowledgeIngestBatchSourceSchema = getKnowledgeIngestBatchSourceSchema();
-export const KnowledgeIngestBatchSourceWithMessageSchema =
-  getKnowledgeIngestBatchSourceWithMessageSchema();
-export const JobBatchStatusCountsSchema = getJobBatchStatusCountsSchema();
-export const JobBatchResultSchema = getJobBatchResultSchema();
-export const JobBatchSchema = getJobBatchSchema();
-export const JobTargetDefinitionSchema = getJobTargetDefinitionSchema();
-export const JobTargetDefinitionsResponseSchema = getJobTargetDefinitionsResponseSchema();
-export const CronJobSchema = getCronJobSchema();
-export const PaginatedCronJobsResponseSchema = getPaginatedCronJobsResponseSchema();
+export const JobStatusSchema = lazySchema(getJobStatusSchema);
+export const CronJobStatusSchema = lazySchema(getCronJobStatusSchema);
+export const JobKindSchema = lazySchema(getJobKindSchema);
+export const ReservedJobTargetFamilySchema = lazySchema(getReservedJobTargetFamilySchema);
+export const PageInfoSchema = lazySchema(getPageInfoSchema);
+export const KnowledgeIngestFileResultSchema = lazySchema(getKnowledgeIngestFileResultSchema);
+export const KnowledgeIngestSkippedFileResultSchema = lazySchema(
+  getKnowledgeIngestSkippedFileResultSchema,
+);
+export const KnowledgeIngestFailedFileResultSchema = lazySchema(
+  getKnowledgeIngestFailedFileResultSchema,
+);
+export const KnowledgeIngestJobResultMetadataSchema = lazySchema(
+  getKnowledgeIngestJobResultMetadataSchema,
+);
+export const KnowledgeIngestJobResultCountsSchema = lazySchema(
+  getKnowledgeIngestJobResultCountsSchema,
+);
+export const KnowledgeIngestJobResultSchema = lazySchema(getKnowledgeIngestJobResultSchema);
+export const JobResultSchema = lazySchema(getJobResultSchema);
+export const JobResultSummarySchema = lazySchema(getJobResultSummarySchema);
+export const JobSchema = lazySchema(getJobSchema);
+export const JobListItemSchema = lazySchema(getJobListItemSchema);
+export const PaginatedJobsResponseSchema = lazySchema(getPaginatedJobsResponseSchema);
+export const JobEventSchema = lazySchema(getJobEventSchema);
+export const JobEventsResponseSchema = lazySchema(getJobEventsResponseSchema);
+export const JobLogsResponseSchema = lazySchema(getJobLogsResponseSchema);
+export const KnowledgeIngestBatchSourceSchema = lazySchema(getKnowledgeIngestBatchSourceSchema);
+export const KnowledgeIngestBatchSourceWithMessageSchema = lazySchema(
+  getKnowledgeIngestBatchSourceWithMessageSchema,
+);
+export const JobBatchStatusCountsSchema = lazySchema(getJobBatchStatusCountsSchema);
+export const JobBatchResultSchema = lazySchema(getJobBatchResultSchema);
+export const JobBatchSchema = lazySchema(getJobBatchSchema);
+export const JobTargetDefinitionSchema = lazySchema(getJobTargetDefinitionSchema);
+export const JobTargetDefinitionsResponseSchema = lazySchema(getJobTargetDefinitionsResponseSchema);
+export const CronJobSchema = lazySchema(getCronJobSchema);
+export const PaginatedCronJobsResponseSchema = lazySchema(getPaginatedCronJobsResponseSchema);
 
 // Inferred types
 export type JobStatus = InferSchema<ReturnType<typeof getJobStatusSchema>>;

package/src/src/mcp/schemas/mcp.schema.ts

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 
 /**
@@ -50,9 +50,9 @@ export const getMCPStatsSchema = defineSchema((v) =>
 );
 
 // Backward-compat aliases
-export const MCPAuthConfigSchema = getMCPAuthConfigSchema();
-export const MCPServerConfigSchema = getMCPServerConfigSchema();
-export const MCPStatsSchema = getMCPStatsSchema();
+export const MCPAuthConfigSchema = lazySchema(getMCPAuthConfigSchema);
+export const MCPServerConfigSchema = lazySchema(getMCPServerConfigSchema);
+export const MCPStatsSchema = lazySchema(getMCPStatsSchema);
 
 // Inferred types
 export type MCPServerConfig = InferSchema<ReturnType<typeof getMCPServerConfigSchema>>;

package/src/src/oauth/schemas/oauth.schema.ts

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 
 export const getOAuthProviderConfigSchema = defineSchema((v) =>
@@ -97,10 +97,10 @@ export type AuthorizationUrlOptions = InferSchema<
 export type TokenExchangeOptions = InferSchema<ReturnType<typeof getTokenExchangeOptionsSchema>>;
 
 // Backward compat aliases
-export const OAuthProviderConfigSchema = getOAuthProviderConfigSchema();
-export const OAuthServiceConfigSchema = getOAuthServiceConfigSchema();
-export const OAuthTokensSchema = getOAuthTokensSchema();
-export const OAuthStateSchema = getOAuthStateSchema();
-export const TokenExchangeResultSchema = getTokenExchangeResultSchema();
-export const AuthorizationUrlOptionsSchema = getAuthorizationUrlOptionsSchema();
-export const TokenExchangeOptionsSchema = getTokenExchangeOptionsSchema();
+export const OAuthProviderConfigSchema = lazySchema(getOAuthProviderConfigSchema);
+export const OAuthServiceConfigSchema = lazySchema(getOAuthServiceConfigSchema);
+export const OAuthTokensSchema = lazySchema(getOAuthTokensSchema);
+export const OAuthStateSchema = lazySchema(getOAuthStateSchema);
+export const TokenExchangeResultSchema = lazySchema(getTokenExchangeResultSchema);
+export const AuthorizationUrlOptionsSchema = lazySchema(getAuthorizationUrlOptionsSchema);
+export const TokenExchangeOptionsSchema = lazySchema(getTokenExchangeOptionsSchema);

package/src/src/platform/compat/kv/factory.ts

@@ -5,7 +5,7 @@ import { isDeno } from "../runtime.js";
 import { MemoryKv } from "./memory-adapter.js";
 import { SqliteKv } from "./sqlite-adapter.js";
 import type { Kv, SqliteDatabase } from "./types.js";
-import type { NodeCompat } from "../../../extensions/compat/node-compat.js";
+import type { SqliteStore } from "../../../extensions/compat/native-services.js";
 
 interface GlobalWithDenoKv {
   Deno?: {
@@ -27,20 +27,20 @@ export async function openKv(path?: string): Promise<Kv> {
     }
   }
 
-  const nodeCompat = tryResolve<NodeCompat>("NodeCompat");
-  if (nodeCompat?.openSqliteDatabase) {
+  const sqliteStore = tryResolve<SqliteStore>("SqliteStore");
+  if (sqliteStore?.openSqliteDatabase) {
     try {
-      const db = await nodeCompat.openSqliteDatabase(path);
-      // NodeCompatSqliteDatabase is structurally identical to SqliteDatabase;
+      const db = await sqliteStore.openSqliteDatabase(path);
+      // Extension SqliteDatabase is structurally identical to SqliteDatabase;
       // cast to satisfy the SqliteKv constructor's nominal type check.
       return new SqliteKv(db as unknown as SqliteDatabase);
     } catch (error) {
-      serverLogger.debug("NodeCompat.openSqliteDatabase failed, using memory KV:", error);
+      serverLogger.debug("SqliteStore.openSqliteDatabase failed, using memory KV:", error);
     }
   } else {
     serverLogger.debug(
-      "NodeCompat extension not registered — SQLite KV unavailable. " +
-        "Install @veryfront/ext-node-compatibility to enable SQLite-backed KV.",
+      "SqliteStore extension not registered. SQLite KV unavailable. " +
+        "Install @veryfront/ext-db-sqlite to enable SQLite-backed KV.",
     );
   }
 

package/src/src/platform/compat/opaque-deps.ts

@@ -20,7 +20,7 @@ import * as dntShim from "../../../_dnt.shims.js";
 import { tryResolve } from "../../extensions/contracts.js";
 import { isDeno } from "./runtime.js";
 import { dynamicImport } from "./dynamic-import.js";
-import type { NodeCompat } from "../../extensions/compat/node-compat.js";
+import type { DocumentExtractor } from "../../extensions/compat/native-services.js";
 
 function resolve(pkg: string, version: string): string {
   return isDeno ? `npm:${pkg}@${version}` : pkg;
@@ -45,12 +45,13 @@ export function importClaudeAgentSDK(): Promise<OpaqueModule> {
 /**
  * Lazily import kreuzberg document extraction.
  *
- * Delegates to the `NodeCompat` extension contract (`@veryfront/ext-node-compatibility`)
+ * Delegates to the `DocumentExtractor` extension contract
+ * (`@veryfront/ext-document-kreuzberg`)
  * when available. Without the extension, throws an actionable error instructing
- * the user to install `ext-node-compatibility`.
+ * the user to install `ext-document-kreuzberg`.
  *
  * Node/Bun path: `@kreuzberg/node` resolved from the project's node_modules at
- * runtime — the extension handles that dynamic import internally.
+ * runtime. The extension handles that dynamic import internally.
  */
 export async function importKreuzberg(): Promise<{
   extractBytes: (
@@ -58,12 +59,12 @@ export async function importKreuzberg(): Promise<{
     mimeType: string,
   ) => Promise<{ content: string }>;
 }> {
-  const nodeCompat = tryResolve<NodeCompat>("NodeCompat");
-  if (nodeCompat?.importKreuzberg) {
-    return nodeCompat.importKreuzberg();
+  const extractor = tryResolve<DocumentExtractor>("DocumentExtractor");
+  if (extractor?.importKreuzberg) {
+    return extractor.importKreuzberg();
   }
   throw new Error(
-    "Document extraction requires the NodeCompat extension. " +
-      "Install @veryfront/ext-node-compatibility and add it to your extensions configuration.",
+    "Document extraction requires a DocumentExtractor extension. " +
+      "Install @veryfront/ext-document-kreuzberg and add it to your extensions configuration.",
   );
 }

package/src/src/platform/compat/std/front-matter-yaml.ts

@@ -1,11 +1,10 @@
-/****
+/**
  * Portable @std/front-matter/yaml shim.
- * Uses gray-matter for consistent, feature-complete parsing across runtimes.
  *
  * @module
  */
 
-import grayMatterImport from "gray-matter";
+import { parse } from "../../../../deps/jsr.io/@std/yaml/1.1.0/parse.js";
 
 export interface Extract<T> {
   attrs: T;
@@ -13,38 +12,28 @@ export interface Extract<T> {
   frontMatter: string;
 }
 
-type GrayMatterResult<T> = { data: T; content: string; matter?: string };
-type GrayMatterEngine = { parse: () => never };
-type GrayMatterOptions = { engines?: Record<string, GrayMatterEngine> };
-type GrayMatterFn = <T = Record<string, unknown>>(
-  content: string,
-  options?: GrayMatterOptions,
-) => GrayMatterResult<T>;
-
-const grayMatter: GrayMatterFn = (grayMatterImport as { default?: GrayMatterFn }).default ??
-  (grayMatterImport as GrayMatterFn);
-
-/** Security: override both "js" and "javascript" engine aliases to block eval on untrusted frontmatter */
-const DISABLED_ENGINE: GrayMatterEngine = {
-  parse: () => {
-    throw new Error("JavaScript frontmatter is disabled for security");
-  },
-};
-const SAFE_OPTIONS: GrayMatterOptions = {
-  engines: { js: DISABLED_ENGINE, javascript: DISABLED_ENGINE },
-};
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)(?:\r?\n)?---(?:\r?\n|$)([\s\S]*)$/;
 
 export function extract<T = Record<string, unknown>>(text: string): Extract<T> {
-  const result = grayMatter<T>(text, SAFE_OPTIONS);
+  const match = text.match(FRONTMATTER_RE);
+  if (!match) {
+    return {
+      attrs: {} as T,
+      body: text,
+      frontMatter: "",
+    };
+  }
+
+  const frontMatter = match[1] ?? "";
+  const parsed = frontMatter.trim() ? parse(frontMatter) : {};
+  const attrs = (parsed && typeof parsed === "object" ? parsed : {}) as T;
   return {
-    attrs: result.data,
-    body: result.content,
-    frontMatter: result.matter ?? "",
+    attrs,
+    body: match[2] ?? "",
+    frontMatter,
   };
 }
 
 export function test(text: string): boolean {
-  const testFn = (grayMatter as GrayMatterFn & { test?: (input: string) => boolean }).test;
-  if (testFn) return testFn(text);
   return /^---\r?\n/.test(text);
 }

package/src/src/react/components/chat/theme.ts

@@ -8,8 +8,6 @@
  */
 
 import { type ClassValue, clsx } from "../../../utils/clsx.js";
-import { twMerge } from "tailwind-merge";
-export { cva, type VariantProps } from "class-variance-authority";
 
 // ---------------------------------------------------------------------------
 // CSS Custom Property tokens
@@ -209,21 +207,58 @@ export function mergeThemes<T>(
 }
 
 /**
- * Utility to combine and merge Tailwind class names.
+ * Utility to combine class names.
  */
 export function cn(...inputs: ClassValue[]): string {
-  return twMerge(clsx(inputs));
+  return clsx(inputs);
 }
 
 // ---------------------------------------------------------------------------
-// CVA Variant Definitions
+// Variant definitions
 // ---------------------------------------------------------------------------
 
-import { cva } from "class-variance-authority";
+type VariantMap = Record<string, Record<string, ClassValue>>;
 
-type CvaReturn = ReturnType<typeof cva>;
+type VariantOptions<TVariants extends VariantMap> =
+  & {
+    [TKey in keyof TVariants]?: keyof TVariants[TKey] | null | undefined;
+  }
+  & {
+    class?: ClassValue;
+    className?: ClassValue;
+  };
+
+type VariantClassFunction<TVariants extends VariantMap> = (
+  options?: VariantOptions<TVariants>,
+) => string;
+
+function variantClasses<TVariants extends VariantMap>(
+  base: ClassValue,
+  config: {
+    variants: TVariants;
+    defaultVariants?: Partial<
+      {
+        [TKey in keyof TVariants]: keyof TVariants[TKey] | null | undefined;
+      }
+    >;
+  },
+): VariantClassFunction<TVariants> {
+  return (options = {}) => {
+    const classes: ClassValue[] = [base];
+
+    for (const [variantName, variantValues] of Object.entries(config.variants)) {
+      const selected = options[variantName] ??
+        config.defaultVariants?.[variantName];
+      if (selected === null || selected === undefined) continue;
+      classes.push(variantValues[String(selected)]);
+    }
+
+    classes.push(options.class, options.className);
+    return cn(classes);
+  };
+}
 
-export const messageVariants: CvaReturn = cva("", {
+export const messageVariants = variantClasses("", {
   variants: {
     role: {
       user:
@@ -239,7 +274,7 @@ export const messageVariants: CvaReturn = cva("", {
   },
 });
 
-export const chatButtonVariants: CvaReturn = cva(
+export const chatButtonVariants = variantClasses(
   [
     "inline-flex items-center justify-center gap-2 whitespace-nowrap",
     "font-medium rounded-full transition-all duration-150",
@@ -273,7 +308,7 @@ export const chatButtonVariants: CvaReturn = cva(
   },
 );
 
-export const chatContainerVariants: CvaReturn = cva("flex flex-col overflow-hidden", {
+export const chatContainerVariants = variantClasses("flex flex-col overflow-hidden", {
   variants: {
     variant: {
       default: "h-full bg-[var(--background)]",

package/src/src/rendering/layouts/layout-applicator.ts

@@ -8,6 +8,8 @@ import type { VeryfrontConfig } from "../../config/index.js";
 import type { ImportMapConfig } from "../../modules/import-map/types.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../observability/tracing/span-names.js";
+import { resolve as resolveContract } from "../../extensions/contracts.js";
+import type { ContentProcessor } from "../../extensions/content/index.js";
 import type { LayoutComponentCache } from "./utils/component-loader.js";
 import { applyLayoutsESM, applyLayoutsFunctionBody } from "./utils/applicator.js";
 import { resolveAppComponentPath } from "./utils/app-resolver.js";
@@ -365,25 +367,15 @@ export class LayoutApplicator {
     appPath: string,
   ): Promise<BundledReact.ComponentType<Record<string, unknown>> | null> {
     try {
-      const { compile } = await import("@mdx-js/mdx");
-      const { getRehypePlugins, getRemarkPlugins } = await import(
-        "../../transforms/plugins/plugin-loader.js"
-      );
-
       const body = source.trim().startsWith("---") ? extract(source).body : source;
 
-      const [remarkPlugins, rehypePlugins] = await Promise.all([
-        getRemarkPlugins(),
-        getRehypePlugins(),
-      ]);
-
-      const compiled = await compile(body, {
-        jsx: true,
-        jsxRuntime: "automatic",
-        jsxImportSource: "react",
-        development: this.mode === "development",
-        remarkPlugins,
-        rehypePlugins,
+      const processor = resolveContract<ContentProcessor>("ContentProcessor");
+      const compiled = await processor.compileMdx({
+        projectDir: this.projectDir,
+        content: body,
+        filePath: appPath,
+        mode: this.mode,
+        target: "server",
       });
 
       const { loadComponentFromSource } = await import(
@@ -391,7 +383,7 @@ export class LayoutApplicator {
       );
 
       return await loadComponentFromSource(
-        String(compiled),
+        compiled.compiledCode,
         appPath.replace(/\.mdx?$/, ".jsx"),
         this.projectDir,
         this.adapter,

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

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 
 export const getRepositoryContextSchema = defineSchema((v) =>
@@ -36,6 +36,6 @@ export type CacheRepositoryOptions = InferSchema<
 >;
 
 // Backward compat aliases
-export const RepositoryContextSchema = getRepositoryContextSchema();
-export const CacheStatsSchema = getCacheStatsSchema();
-export const CacheRepositoryOptionsSchema = getCacheRepositoryOptionsSchema();
+export const RepositoryContextSchema = lazySchema(getRepositoryContextSchema);
+export const CacheStatsSchema = lazySchema(getCacheStatsSchema);
+export const CacheRepositoryOptionsSchema = lazySchema(getCacheRepositoryOptionsSchema);

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

@@ -1,4 +1,4 @@
-import { defineSchema } from "../../schemas/index.js";
+import { defineSchema, lazySchema } from "../../schemas/index.js";
 import type { InferSchema } from "../../extensions/schema/index.js";
 
 export const getCachePolicySchema = defineSchema((v) =>
@@ -13,8 +13,8 @@ export const getMcpConfigSchema = defineSchema((v) =>
 );
 
 // Backward-compat aliases
-export const cachePolicySchema = getCachePolicySchema();
-export const McpConfigSchema = getMcpConfigSchema();
+export const cachePolicySchema = lazySchema(getCachePolicySchema);
+export const McpConfigSchema = lazySchema(getMcpConfigSchema);
 
 // Inferred types
 export type CachePolicy = InferSchema<ReturnType<typeof getCachePolicySchema>>;

package/src/src/sandbox/agent-service-tools.ts

@@ -32,6 +32,7 @@ export interface AgentServiceSandboxClient
 export interface AgentServiceSandboxClientOptions extends LazySandboxOptions {}
 
 export interface AgentServiceSandboxToolsOptions extends AgentServiceSandboxClientOptions {
+  /** Sandbox shell tools provider. Kept as createBashTool for caller compatibility. */
   createBashTool: CreateSandboxBashTool;
 }
 

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

@@ -1,5 +1,18 @@
-import type { Tool, ToolExecutionContext } from "../tool/index.js";
+import type { ToolExecutionContext } from "../tool/index.js";
 import type { JsonSchema } from "../tool/schema/json-schema.js";
+import type {
+  SandboxShellClient,
+  SandboxShellToolDefinition,
+  SandboxShellToolSet,
+  SandboxShellToolsProvider,
+} from "../extensions/sandbox/index.js";
+
+export type {
+  SandboxShellClient as BashToolSandboxLike,
+  SandboxShellToolDefinition,
+  SandboxShellToolSet,
+  SandboxShellToolsProvider as CreateSandboxBashTool,
+} from "../extensions/sandbox/index.js";
 
 const SANDBOX_WORKING_DIRECTORY = "/workspace";
 const SANDBOX_TOOL_PROMPT =
@@ -15,44 +28,6 @@ const JSON_SCHEMA_TYPES: ReadonlySet<string> = new Set([
   "null",
 ]);
 
-type SandboxShellToolExecute = {
-  bivarianceHack: (input: unknown, options?: ToolExecutionContext) => Promise<unknown> | unknown;
-}["bivarianceHack"];
-
-export type SandboxShellToolDefinition = {
-  id?: string;
-  type?: Tool["type"];
-  title?: string;
-  description?: string;
-  inputSchema?: unknown;
-  inputSchemaJson?: JsonSchema;
-  parameters?: unknown;
-  providerOptions?: unknown;
-  execute?: Tool["execute"] | SandboxShellToolExecute;
-  mcp?: Tool["mcp"];
-};
-
-export type SandboxShellToolSet = Record<string, SandboxShellToolDefinition>;
-
-export type BashToolSandboxLike = {
-  ensure?: () => Promise<void> | void;
-  executeCommand: (command: string, options?: unknown) => Promise<unknown>;
-  readFile?: (path: string) => Promise<unknown> | unknown;
-  writeFiles?: (files: unknown[]) => Promise<unknown> | unknown;
-};
-
-type CreateBashToolInput = {
-  sandbox: BashToolSandboxLike;
-  destination: string;
-  promptOptions: {
-    toolPrompt: string;
-  };
-};
-
-export type CreateSandboxBashTool = (
-  input: CreateBashToolInput,
-) => Promise<{ tools: Record<string, unknown> }>;
-
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -227,10 +202,10 @@ export function renameSandboxFileTools(bashTools: SandboxShellToolSet): SandboxS
 }
 
 export async function createSandboxShellTools(
-  sandbox: BashToolSandboxLike,
-  createBashTool: CreateSandboxBashTool,
+  sandbox: SandboxShellClient,
+  createShellTools: SandboxShellToolsProvider,
 ): Promise<SandboxShellToolSet> {
-  const { tools: bashTools } = await createBashTool({
+  const { tools: bashTools } = await createShellTools({
     sandbox,
     destination: SANDBOX_WORKING_DIRECTORY,
     promptOptions: {

package/src/src/schemas/define.ts

@@ -5,23 +5,17 @@
  * `SchemaValidator` extension contract on first call and materializes the
  * schema via the provided factory. This indirection lets core modules declare
  * schemas without importing zod directly — a real validator (typically
- * `@veryfront/ext-zod`) must be registered in the contract registry before
+ * `@veryfront/ext-schema-zod`) must be registered in the contract registry before
  * the schema is first accessed.
  *
  * @module schemas/define
  */
 
-import { register, tryResolve } from "../extensions/contracts.js";
+import { resolve } 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;
+  return resolve<SchemaValidator>("SchemaValidator");
 }
 
 /**
@@ -29,7 +23,7 @@ export function resolveSchemaValidator(): SchemaValidator {
  *
  * @param factory - Receives a `SchemaValidator` and returns a `Schema<T>`.
  * @returns A zero-arg getter that caches and returns the built schema.
- * Installs the default zod-backed validator when no contract is registered.
+ * Requires a SchemaValidator extension to be registered before first use.
  *
  * @example
  * ```ts

package/src/src/schemas/index.ts

@@ -4,7 +4,7 @@
  * plus the `defineSchema` lazy-factory helper.
  *
  * `defineSchema` resolves the `SchemaValidator` contract on first use. The
- * default zod-backed implementation lives in `@veryfront/ext-zod` and is
+ * default zod-backed implementation lives in `@veryfront/ext-schema-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.
@@ -13,6 +13,7 @@
  */
 
 export { defineSchema } from "./define.js";
+export { lazySchema } from "./lazy.js";
 
 export {
   isOptionalSchema as schemaIsOptional,