veryfront 0.1.283 → 0.1.285

package/src/src/provider/veryfront-cloud/provider.ts

@@ -1,9 +1,8 @@
 import { createError, toError } from "../../errors/veryfront-error.js";
-import {
-  createAnthropicModelRuntime,
-  createGoogleModelRuntime,
-  createOpenAIModelRuntime,
-} from "../runtime-loader.js";
+import { createGoogleModelRuntime } from "../runtime-loader.js";
+import { tryResolve } from "../../extensions/contracts.js";
+import type { AIProviderRegistry } from "../../extensions/interfaces/index.js";
+import { AIProviderRegistryName } from "../../extensions/interfaces/index.js";
 import type { ModelRuntime } from "../types.js";
 import {
   createVeryfrontCloudFetch,
@@ -19,13 +18,22 @@ export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
   const fetch = createVeryfrontCloudFetch(apiToken, projectSlug);
 
   switch (provider) {
-    case "anthropic":
-      return createAnthropicModelRuntime({
-        authToken: apiToken,
-        baseURL,
-        name: "veryfront-cloud",
-        fetch,
-      }, upstreamModelId);
+    case "anthropic": {
+      const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+      const anthropic = registry?.get("anthropic");
+      if (anthropic) {
+        return anthropic.createModel(upstreamModelId, {
+          credential: apiToken,
+          authToken: apiToken,
+          baseURL,
+          name: "veryfront-cloud",
+          fetch,
+        });
+      }
+      throw new Error(
+        "Anthropic provider not installed. Add @veryfront/ext-anthropic to use anthropic/* models via veryfront-cloud.",
+      );
+    }
 
     case "google":
       return createGoogleModelRuntime({
@@ -36,13 +44,21 @@ export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
       }, upstreamModelId);
 
     case "openai":
-    case "moonshotai":
-      return createOpenAIModelRuntime({
-        apiKey: apiToken,
-        baseURL,
-        name: "veryfront-cloud",
-        fetch,
-      }, upstreamModelId);
+    case "moonshotai": {
+      const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+      const openai = registry?.get("openai");
+      if (openai) {
+        return openai.createModel(upstreamModelId, {
+          credential: apiToken,
+          baseURL,
+          name: "veryfront-cloud",
+          fetch,
+        });
+      }
+      throw new Error(
+        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/moonshotai models via veryfront-cloud.",
+      );
+    }
 
     default: {
       const _exhaustive: never = provider;

package/src/src/sandbox/index.ts

@@ -34,4 +34,8 @@ export {
   type SandboxOptions,
   type SandboxSession,
 } from "./sandbox.js";
-export { LazySandbox, type LazySandboxOptions } from "./lazy-sandbox.js";
+export {
+  LazySandbox,
+  type LazySandboxOptions,
+  resolveDefaultSandboxRuntimeEndpoint,
+} from "./lazy-sandbox.js";

package/src/src/sandbox/lazy-sandbox.ts

@@ -1,5 +1,6 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { REQUEST_ERROR } from "../errors/index.js";
+import { getHostEnv } from "../platform/compat/process.js";
 import {
   type CommandJob,
   type CommandJobOutput,
@@ -45,6 +46,28 @@ const REPROVISIONABLE_EXEC_START_ERROR_CODES = new Set([
   "ENOTFOUND",
   "EHOSTUNREACH",
 ]);
+const VERYFRONT_SANDBOX_PUBLIC_HOST_PATTERN = /^([a-z0-9-]+)\.sandbox\.veryfront\.[a-z0-9.-]+$/i;
+
+export function resolveDefaultSandboxRuntimeEndpoint(input: { endpoint: string }): string {
+  if (!getHostEnv("KUBERNETES_SERVICE_HOST")) {
+    return input.endpoint;
+  }
+
+  let hostname: string;
+  try {
+    hostname = new URL(input.endpoint).hostname;
+  } catch {
+    return input.endpoint;
+  }
+
+  const match = hostname.match(VERYFRONT_SANDBOX_PUBLIC_HOST_PATTERN);
+  const shortId = match?.[1];
+  if (!shortId) {
+    return input.endpoint;
+  }
+
+  return `http://sandbox.veryfront-sandbox-${shortId}.svc.cluster.local`;
+}
 
 /** Lazily provisions sandbox sessions and keeps them alive while in use. */
 export class LazySandbox {
@@ -625,7 +648,8 @@ export class LazySandbox {
   private resolveRuntimeEndpoint(): string {
     const endpoint = this.requireEndpoint();
     const sessionId = this.requireSessionId();
-    return this.resolveRuntimeEndpointOption?.({ endpoint, sessionId }) ?? endpoint;
+    return this.resolveRuntimeEndpointOption?.({ endpoint, sessionId }) ??
+      resolveDefaultSandboxRuntimeEndpoint({ endpoint });
   }
 
   private requireSessionId(): string {

package/src/src/schemas/define.ts

@@ -0,0 +1,48 @@
+/**
+ * Lazy schema factory.
+ *
+ * `defineSchema(factory)` returns a memoized getter that resolves the
+ * `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
+ * the schema is first accessed.
+ *
+ * @module schemas/define
+ */
+
+import { tryResolve } from "../extensions/contracts.js";
+import type {
+  Schema,
+  SchemaFactory,
+  SchemaValidator,
+} from "../extensions/interfaces/index.js";
+
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * const getUserSchema = defineSchema((v) =>
+ *   v.object({ id: v.string().uuid(), name: v.string().min(1) })
+ * );
+ *
+ * const user = getUserSchema().parse(input);
+ * ```
+ */
+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");
+    }
+    cached = factory(v);
+    return cached;
+  };
+}

package/src/src/schemas/index.ts

@@ -1,10 +1,21 @@
 /**
- * Reusable Zod validation schemas — common types (email, slug, URL, UUID,
- * pagination) and primitives (file paths, hex colors, semver, timestamps).
+ * Reusable validation schemas — common types (email, slug, URL, UUID,
+ * 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.
  *
  * @module schemas
  */
 
+import { registerZodAdapter } from "./zod-adapter.js";
+
+// Register the default SchemaValidator implementation once at module load.
+registerZodAdapter();
+
+export { defineSchema } from "./define.js";
+
 export {
   CommonSchemas,
   type DateRange,

package/src/src/schemas/zod-adapter.ts

@@ -0,0 +1,180 @@
+/**
+ * Zod-backed `SchemaValidator` adapter.
+ *
+ * This is the default (core-provided) 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; when
+ * `@veryfront/ext-zod` takes over in Phase B this file will be deleted and
+ * the `"zod"` import map entry removed.
+ *
+ * @module schemas/zod-adapter
+ */
+
+import { z } from "zod";
+import { register } from "../extensions/contracts.js";
+import type {
+  InferShape,
+  Schema,
+  SchemaValidator,
+  SchemaValidatorCoerce,
+  ValidationIssue,
+  ValidationResult,
+} from "../extensions/interfaces/index.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: T | (() => T)) => wrap<T>(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)),
+    transform: <U>(fn: (value: T) => U) => wrap<U>(zs.transform(fn as never)),
+    strict: () => wrap<T>(anyZs.strict()),
+    passthrough: () => wrap<T>(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))),
+    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)),
+    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()),
+};
+
+/** The zod-backed `SchemaValidator` singleton registered by `registerZodAdapter`. */
+export const zodAdapter: SchemaValidator = {
+  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()),
+  // deno-lint-ignore no-explicit-any -- contract mirrors zod's `any` constructor
+  any: (): Schema<any> => wrap(z.any()),
+
+  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))),
+
+  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),
+    ),
+
+  coerce,
+
+  validate: <T>(schema: Schema<T>, data: unknown): ValidationResult<T> => schema.safeParse(data),
+};
+
+/**
+ * Register the zod adapter as the default `SchemaValidator` implementation.
+ *
+ * Called once at core bootstrap (`src/schemas/index.ts` side-effect import).
+ * Phase B will delete this function when `@veryfront/ext-zod` takes over.
+ */
+export function registerZodAdapter(): void {
+  register<SchemaValidator>("SchemaValidator", zodAdapter);
+}

package/src/src/server/bootstrap.ts

@@ -3,6 +3,8 @@ import type { VeryfrontConfig } from "../config/index.js";
 import type { InvalidationProjectContext } from "../platform/adapters/fs/veryfront/types.js";
 import { clearConfigCache, getConfig } from "../config/index.js";
 import { type ExtensionLoader, orchestrateExtensions, tryResolve } from "../extensions/index.js";
+import { AIProviderRegistryName } from "../extensions/interfaces/index.js";
+import { createAIProviderRegistry } from "../extensions/registries/ai-provider-registry.js";
 import type { TracingExporter } from "../extensions/interfaces/tracing-exporter.js";
 import {
   setGlobalActiveSpanAccessor,
@@ -198,6 +200,7 @@ export async function bootstrap(
       projectDir,
       config,
       logger: bootstrapLog,
+      primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
     });
     wireTracingShim();
     return {
@@ -239,6 +242,7 @@ export async function bootstrap(
       projectDir,
       config,
       logger: bootstrapLog,
+      primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
     });
     wireTracingShim();
     return {
@@ -302,6 +306,7 @@ export async function bootstrap(
         projectDir,
         config,
         logger: bootstrapLog,
+        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
       }),
     fsDispose,
   );

package/src/src/transforms/plugins/babel-node-positions.ts

@@ -1,184 +1,22 @@
 /**
- * Babel Transform for TSX Source Position Injection
+ * Shim over the `CodeParser` contract's `injectJsxNodePositions()` method.
  *
- * Injects data-node-* attributes into JSX elements for Studio Navigator integration.
- * This mirrors the position tracking done by remarkAddNodeId for MDX files.
+ * The actual Babel-based implementation lives in `@veryfront/ext-babel`.
+ * Core modules continue to import from this path; the shim resolves the
+ * contract at call time. Position injection powers Studio Navigator only —
+ * if `ext-babel` is not installed we return the source unchanged rather
+ * than fail the SSR path.
  */
 
-import * as parser from "@babel/parser";
-import * as traverseModule from "@babel/traverse";
-import * as generateModule from "@babel/generator";
-import * as t from "@babel/types";
-
-// Local type definitions for Babel traverse/generate (they don't bundle types)
-interface BabelNodePath<T = t.Node> {
-  node: T;
-  parent: t.Node;
-  parentPath: BabelNodePath | null;
-  scope: unknown;
-  type: string;
-  skip(): void;
-  stop(): void;
-}
-
-interface BabelGeneratorResult {
-  code: string;
-  map?: unknown;
-}
-
-type TraverseFunction = (ast: t.Node, opts: Record<string, unknown>) => void;
-type GenerateFunction = (ast: t.Node, opts?: Record<string, unknown>) => BabelGeneratorResult;
-
-interface ModuleWithDefault<T> {
-  default: T | { default: T };
-}
-
-function resolveDefaultExport<T>(mod: unknown): T {
-  const m = mod as ModuleWithDefault<T>;
-  if (typeof m.default === "function") return m.default as T;
-
-  const nested = m.default as { default?: T } | undefined;
-  if (typeof nested?.default === "function") return nested.default as T;
-
-  return mod as T;
-}
-
-const traverse: TraverseFunction = resolveDefaultExport<TraverseFunction>(traverseModule);
-const generate: GenerateFunction = resolveDefaultExport<GenerateFunction>(generateModule);
-
-const SKIPPED_ELEMENTS = new Set([
-  "html",
-  "head",
-  "title",
-  "body",
-  "link",
-  "base",
-  "meta",
-  "script",
-  "style",
-  "noscript",
-  "template",
-  "svg",
-  "path",
-  "circle",
-  "ellipse",
-  "line",
-  "polygon",
-  "polyline",
-  "rect",
-  "g",
-  "defs",
-  "linearGradient",
-  "radialGradient",
-  "stop",
-  "text",
-  "tspan",
-  "use",
-  "filter",
-]);
+import { tryResolve } from "../../extensions/contracts.js";
+import type { CodeParser } from "../../extensions/interfaces/index.js";
 
 interface TransformOptions {
   filePath: string;
 }
 
-function getElementName(openingElement: t.JSXOpeningElement): string {
-  const { name } = openingElement;
-
-  if (t.isJSXIdentifier(name)) return name.name;
-
-  if (!t.isJSXMemberExpression(name)) return "DynamicComponent";
-
-  const parts: string[] = [];
-  let current: t.JSXMemberExpression | t.JSXIdentifier = name;
-
-  while (t.isJSXMemberExpression(current)) {
-    if (t.isJSXIdentifier(current.property)) parts.unshift(current.property.name);
-    current = current.object;
-  }
-
-  if (t.isJSXIdentifier(current)) parts.unshift(current.name);
-
-  return parts.length ? parts.join(".") : "MemberExpression";
-}
-
-function isFragment(openingElement: t.JSXOpeningElement): boolean {
-  const { name } = openingElement;
-
-  if (t.isJSXMemberExpression(name)) {
-    return (
-      t.isJSXIdentifier(name.object) &&
-      name.object.name === "React" &&
-      t.isJSXIdentifier(name.property) &&
-      name.property.name === "Fragment"
-    );
-  }
-
-  return t.isJSXIdentifier(name) && name.name === "Fragment";
-}
-
-function hasPositionAttribute(attributes: (t.JSXAttribute | t.JSXSpreadAttribute)[]): boolean {
-  return attributes.some((attr) => {
-    if (!t.isJSXAttribute(attr) || !t.isJSXIdentifier(attr.name)) return false;
-    return attr.name.name === "data-node-line" || attr.name.name === "data-vf-id";
-  });
-}
-
-/**
- * Transform TSX source to inject position data attributes into JSX elements.
- * This enables Studio Navigator to map rendered elements back to source positions.
- */
 export function injectNodePositions(source: string, options: TransformOptions): string {
-  if (!source.trim()) return source;
-  if (!options.filePath) return source;
-
-  try {
-    const ast = parser.parse(source, {
-      sourceType: "module",
-      plugins: ["typescript", "jsx"],
-    });
-
-    let nodeCounter = 0;
-
-    traverse(ast as t.Node, {
-      JSXElement: {
-        enter(path: BabelNodePath<t.JSXElement>) {
-          const openingElement = path.node.openingElement;
-          const elementName = getElementName(openingElement);
-
-          if (SKIPPED_ELEMENTS.has(elementName.toLowerCase())) return;
-          if (isFragment(openingElement)) return;
-          if (hasPositionAttribute(openingElement.attributes)) return;
-
-          const loc = openingElement.loc;
-          if (!loc) return;
-
-          const nodeId = `node-${nodeCounter++}`;
-          openingElement.attributes.push(
-            t.jsxAttribute(t.jsxIdentifier("data-node-id"), t.stringLiteral(nodeId)),
-            t.jsxAttribute(
-              t.jsxIdentifier("data-node-file"),
-              t.stringLiteral(options.filePath),
-            ),
-            t.jsxAttribute(t.jsxIdentifier("data-node-name"), t.stringLiteral(elementName)),
-            t.jsxAttribute(
-              t.jsxIdentifier("data-node-line"),
-              t.stringLiteral(String(loc.start.line)),
-            ),
-            t.jsxAttribute(
-              t.jsxIdentifier("data-node-column"),
-              t.stringLiteral(String(loc.start.column)),
-            ),
-          );
-        },
-      },
-    });
-
-    return generate(ast as t.Node, {
-      retainLines: true,
-      compact: false,
-    }).code;
-  } catch (_) {
-    /* expected: source may not be parseable TSX/JSX */
-    return source;
-  }
+  const parser = tryResolve<CodeParser>("CodeParser");
+  if (!parser) return source;
+  return parser.injectJsxNodePositions(source, options);
 }

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.283";
+export const VERSION = "0.1.285";