veryfront 0.1.283 → 0.1.285

package/src/src/extensions/loader.ts

@@ -17,6 +17,16 @@ import type { Extension, ExtensionContext, ExtensionLogger, ResolvedExtension }
 export class ExtensionLoader {
   private logger: ExtensionLogger;
   private setupOrder: ResolvedExtension[] = [];
+  private primed: Record<string, unknown> = {};
+
+  /**
+   * Register contracts that will be re-applied after each `setupAll()`
+   * teardown pass. Used by `orchestrateExtensions()` to seed infrastructure
+   * (e.g. `AIProviderRegistry`) before per-extension `setup()` runs.
+   */
+  primeContracts(contracts: Record<string, unknown>): void {
+    this.primed = { ...this.primed, ...contracts };
+  }
 
   constructor(logger: ExtensionLogger) {
     this.logger = logger;
@@ -154,6 +164,10 @@ export class ExtensionLoader {
     // registry even when nothing is loaded yet.
     await this.teardownAll();
 
+    for (const [name, impl] of Object.entries(this.primed)) {
+      register(name, impl);
+    }
+
     // Check for contract conflicts before loading
     const conflicts = detectConflicts(extensions);
     if (conflicts.length > 0) {

package/src/src/extensions/orchestrate.ts

@@ -30,6 +30,8 @@ export interface OrchestrateOptions {
   projectDir: string;
   config: { extensions?: ExtensionConfigEntry[] };
   logger: ExtensionLogger;
+  /** Contracts to seed into the registry after teardown, before setup(). */
+  primeContracts?: Record<string, unknown>;
   /** @internal Override discovery functions in tests. */
   discovery?: {
     discoverPackageExtensions: typeof defaultDiscovery.discoverPackageExtensions;
@@ -167,6 +169,9 @@ export async function orchestrateExtensions(
   );
 
   const loader = new ExtensionLoader(logger);
+  if (options.primeContracts) {
+    loader.primeContracts(options.primeContracts);
+  }
   await loader.setupAll(merged, config as Record<string, unknown>);
   return loader;
 }

package/src/src/extensions/recommendations.ts

@@ -13,7 +13,10 @@ const recommendations = new Map<string, string>([
   ["DatabaseClient", "@veryfront/ext-postgres"],
   ["AuthProvider", "@veryfront/ext-jwt"],
   ["TracingExporter", "@veryfront/ext-opentelemetry"],
-  ["AIModelProvider", "@veryfront/ext-openai"],
+  ["AIProviderRegistry", "@veryfront/ext-openai"],
+  ["AIProvider:openai", "@veryfront/ext-openai"],
+  ["AIProvider:anthropic", "@veryfront/ext-anthropic"],
+  ["AIProvider:google", "@veryfront/ext-google"],
   ["EmbeddingProvider", "@veryfront/ext-embeddings"],
   ["CodeParser", "@veryfront/ext-babel"],
   ["SchemaValidator", "@veryfront/ext-zod"],

package/src/src/extensions/registries/ai-provider-registry.ts

@@ -0,0 +1,53 @@
+/**
+ * Default Map-backed implementation of the AIProviderRegistry contract.
+ *
+ * Preserves insertion order via Map (used by `list()`). Throws on
+ * duplicate id to surface silent collisions between extensions.
+ *
+ * @module extensions/registries/ai-provider-registry
+ */
+
+import type { AIProvider, AIProviderRegistry } from "../interfaces/ai-provider.js";
+
+class AIProviderRegistryImpl implements AIProviderRegistry {
+  private readonly providers = new Map<string, AIProvider>();
+
+  register(provider: AIProvider): void {
+    if (this.providers.has(provider.id)) {
+      throw new Error(
+        `AIProvider "${provider.id}" is already registered. ` +
+          `Call unregister("${provider.id}") first if you intend to replace it.`,
+      );
+    }
+    this.providers.set(provider.id, provider);
+  }
+
+  unregister(id: string): void {
+    this.providers.delete(id);
+  }
+
+  get(id: string): AIProvider | undefined {
+    return this.providers.get(id);
+  }
+
+  require(id: string): AIProvider {
+    const p = this.providers.get(id);
+    if (p) return p;
+    const known = [...this.providers.keys()].join(", ") || "(none)";
+    throw new Error(
+      `No AIProvider registered for "${id}". Known providers: ${known}.`,
+    );
+  }
+
+  has(id: string): boolean {
+    return this.providers.has(id);
+  }
+
+  list(): AIProvider[] {
+    return [...this.providers.values()];
+  }
+}
+
+export function createAIProviderRegistry(): AIProviderRegistry {
+  return new AIProviderRegistryImpl();
+}

package/src/src/html/styles-builder/plugin-loader.ts

@@ -9,9 +9,6 @@
 import * as dntShim from "../../../_dnt.shims.js";
 
 
-import plugin from "tailwindcss/plugin";
-import defaultTheme from "tailwindcss/defaultTheme";
-import colors from "tailwindcss/colors";
 import { serverLogger } from "../../utils/index.js";
 import {
   type ErrorSlug,
@@ -70,19 +67,10 @@ try {
   });
 }
 
-// Set up global shims for tailwindcss subpaths - used by dynamically loaded plugins
-(dntShim.dntGlobalThis as Record<string, unknown>).__tailwindPluginShim = {
-  default: plugin,
-  __esModule: true,
-};
-(dntShim.dntGlobalThis as Record<string, unknown>).__tailwindDefaultThemeShim = {
-  default: defaultTheme,
-  __esModule: true,
-};
-(dntShim.dntGlobalThis as Record<string, unknown>).__tailwindColorsShim = {
-  default: colors,
-  __esModule: true,
-};
+// Global shims for `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and
+// `tailwindcss/colors` used by dynamically loaded plugin bundles are installed
+// by the `@veryfront/ext-tailwind` extension's `setup()` hook — they depend on
+// tailwindcss imports that live in the extension package, not in core.
 
 function isRealDenoRuntime(): boolean {
   return typeof dntShim.Deno !== "undefined" && typeof dntShim.Deno.version === "object";

package/src/src/html/styles-builder/tailwind-compiler-cache.ts

@@ -5,10 +5,17 @@
  * stylesheet hash. Prevents race conditions when concurrent requests use
  * different stylesheets.
  *
+ * The actual tailwindcss `compile()` call is routed through the
+ * `CSSProcessor` extension contract (default implementation:
+ * `@veryfront/ext-tailwind`). When no `CSSProcessor` is registered, the
+ * compile path returns a no-op compiler that emits empty CSS and logs an
+ * actionable install message.
+ *
  * @module html/styles-builder/tailwind-compiler-cache
  */
 
-import { compile } from "tailwindcss";
+import { tryResolve as tryResolveContract } from "../../extensions/contracts.js";
+import type { CSSCompiler, CSSProcessor } from "../../extensions/interfaces/index.js";
 import { serverLogger } from "../../utils/index.js";
 import { DEPENDENCY_MISSING, NETWORK_ERROR } from "../../errors/index.js";
 import { getTailwindCSSUrl } from "../../utils/constants/cdn.js";
@@ -23,7 +30,7 @@ const logger = serverLogger.component("tailwind");
  * Each entry stores the compiler and its associated plugin state.
  */
 interface CompilerCacheEntry {
-  compiler: Awaited<ReturnType<typeof compile>>;
+  compiler: CSSCompiler;
   createdAt: number;
   pluginCache: Map<string, unknown>;
   pluginErrors: Map<string, Error>;
@@ -86,7 +93,7 @@ function evictOldestCompiler(): void {
 export async function getCompiler(
   stylesheet: string,
   projectSlug?: string,
-): Promise<Awaited<ReturnType<typeof compile>>> {
+): Promise<CSSCompiler> {
   // Tailwind v4's compile().build() is stateful — it accumulates candidates
   // across calls. Without per-project isolation, projects sharing the same
   // stylesheet on the shared pool contaminate each other's CSS output.
@@ -101,11 +108,26 @@ export async function getCompiler(
 
   logger.debug("Creating new compiler", { hash, projectSlug });
 
+  const processor = tryResolveContract<CSSProcessor>("CSSProcessor");
+  if (!processor) {
+    logger.warn(
+      "No CSSProcessor extension registered — CSS output will be empty. Install it with: deno add @veryfront/ext-tailwind",
+    );
+    const noopCompiler: CSSCompiler = { build: () => "" };
+    compilerCache.set(hash, {
+      compiler: noopCompiler,
+      createdAt: Date.now(),
+      pluginCache: new Map(),
+      pluginErrors: new Map(),
+    });
+    return noopCompiler;
+  }
+
   const tailwindBase = await getTailwindBaseCSS();
   const pluginCache = new Map<string, unknown>();
   const pluginErrors = new Map<string, Error>();
 
-  const newCompiler = await compile(stylesheet, {
+  const newCompiler = await processor.compile(stylesheet, {
     base: "/",
     loadStylesheet: (id: string) => {
       if (id === "tailwindcss") {
@@ -121,8 +143,7 @@ export async function getCompiler(
           detail: `Failed to load plugin "${id}": plugin not installed`,
         });
       }
-      // deno-lint-ignore no-explicit-any -- dynamically loaded plugin cannot be statically verified against Tailwind's Plugin | Config type
-      return { module: loaded as any, base: "/", path: "/" };
+      return { module: loaded, base: "/", path: "/" };
     },
   });
 

package/src/src/provider/model-registry.ts

@@ -19,6 +19,9 @@ import {
   getGoogleGenAIEnvConfig,
   getOpenAIEnvConfig,
 } from "../config/env.js";
+import { tryResolve } from "../extensions/contracts.js";
+import type { AIProviderRegistry } from "../extensions/interfaces/index.js";
+import { AIProviderRegistryName } from "../extensions/interfaces/index.js";
 import { ProjectScopedRegistryManager } from "../registry/project-scoped-registry-manager.js";
 import { serverLogger } from "../utils/index.js";
 import { DEFAULT_LOCAL_MODEL } from "./local/model-catalog.js";
@@ -29,11 +32,7 @@ import {
   getDefaultVeryfrontCloudModel,
   isVeryfrontCloudEnabled,
 } from "../platform/cloud/resolver.js";
-import {
-  createAnthropicModelRuntime,
-  createGoogleModelRuntime,
-  createOpenAIModelRuntime,
-} from "./runtime-loader.js";
+import { createGoogleModelRuntime } from "./runtime-loader.js";
 import { createVeryfrontCloudModel } from "./veryfront-cloud/provider.js";
 import { getModelRuntimeId, hasLocalModelRuntimeMarker } from "./runtime-inspection.js";
 import type { ModelRuntime } from "./types.js";
@@ -92,10 +91,18 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      return createOpenAIModelRuntime(
-        { apiKey: config.apiKey, baseURL: config.baseURL },
-        id,
-      );
+      const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+      const provider = registry?.get("openai");
+      if (provider) {
+        return provider.createModel(id, {
+          credential: config.apiKey,
+          baseURL: config.baseURL,
+        });
+      }
+      throw toError(createError({
+        type: "config",
+        message: "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/* models.",
+      }));
     });
   }
 
@@ -111,13 +118,19 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      return createAnthropicModelRuntime(
-        {
-          apiKey: config.apiKey,
+      const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+      const provider = registry?.get("anthropic");
+      if (provider) {
+        return provider.createModel(id, {
+          credential: config.apiKey,
           baseURL: config.baseURL,
-        },
-        id,
-      );
+        });
+      }
+      throw toError(createError({
+        type: "config",
+        message:
+          "Anthropic provider not installed. Add @veryfront/ext-anthropic to use anthropic/* models.",
+      }));
     });
   }
 
@@ -207,15 +220,21 @@ function isMissingProviderConfiguration(errorData: ReturnType<typeof fromError>)
  */
 export function findAvailableCloudModel(): string | null {
   autoInitializeFromEnv();
+  const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
   for (const { provider, model, hasKey } of CLOUD_UPGRADE_CANDIDATES) {
     if (!hasKey()) continue;
     if (!manager.has(provider)) continue;
+    if (registry && !registry.has(provider) && !isBuiltinProvider(provider)) continue;
     const resolvedModel = typeof model === "function" ? model() : model;
     return `${provider}/${resolvedModel}`;
   }
   return null;
 }
 
+function isBuiltinProvider(provider: string): boolean {
+  return provider === "google" || provider === "veryfront-cloud";
+}
+
 /**
  * Resolve a "provider/model" string to a framework-compatible model runtime.
  *

package/src/src/provider/runtime-loader/provider-embedding-responses.ts

@@ -1,6 +1,6 @@
 import { readRecord } from "./provider-records.js";
 
-function isNumberArray(value: unknown): value is number[] {
+export function isNumberArray(value: unknown): value is number[] {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
 }
 

package/src/src/provider/runtime-loader/provider-http.ts

@@ -44,7 +44,7 @@ export class ProviderQuotaError extends ProviderError {}
 /** Non-retryable 4xx/5xx that doesn't fit another bucket. */
 export class ProviderRequestError extends ProviderError {}
 
-function parseRetryAfterMs(header: string | null): number | undefined {
+export function parseRetryAfterMs(header: string | null): number | undefined {
   if (!header) return undefined;
   const asNumber = Number(header);
   if (Number.isFinite(asNumber) && asNumber >= 0) {
@@ -65,7 +65,7 @@ function parseRetryAfterMs(header: string | null): number | undefined {
  * where HTTP status alone is ambiguous — notably OpenAI
  * `insufficient_quota` vs `rate_limit_exceeded` both arriving as 429.
  */
-async function buildProviderError(
+export async function buildProviderError(
   provider: ProviderKind,
   response: Response,
 ): Promise<ProviderError> {