veryfront 0.0.6 → 0.0.9

package/dist/ai/client.d.ts

@@ -0,0 +1,2 @@
+// AI client type definitions
+export * from 'ai';

package/dist/ai/components.d.ts

@@ -0,0 +1,11 @@
+// AI styled components type definitions
+import type { ReactNode, HTMLAttributes } from 'react';
+import type { UseChatHelpers } from '@ai-sdk/react';
+
+export interface ChatProps extends Partial<UseChatHelpers> {
+  className?: string;
+  placeholder?: string;
+  welcomeMessage?: string;
+}
+
+export declare function Chat(props: ChatProps): JSX.Element;

package/dist/ai/dev.d.ts

@@ -0,0 +1,7 @@
+// AI development utilities type definitions
+export interface DevToolsConfig {
+  enabled?: boolean;
+  position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+}
+
+export declare function AIDevTools(props: DevToolsConfig): JSX.Element | null;

package/dist/ai/index.d.ts

@@ -0,0 +1,40 @@
+// AI module type definitions
+import type { z } from 'zod';
+
+export interface AgentConfig {
+  model: string;
+  system?: string;
+  tools?: Record<string, boolean | object>;
+  memory?: {
+    type?: 'conversation' | 'summary' | 'buffer';
+    maxTokens?: number;
+  };
+  maxSteps?: number;
+  temperature?: number;
+}
+
+export interface ToolConfig<TInput = unknown, TOutput = unknown> {
+  description: string;
+  inputSchema: z.ZodType<TInput>;
+  execute: (input: TInput) => Promise<TOutput> | TOutput;
+}
+
+export interface ResourceConfig<TParams = unknown, TData = unknown> {
+  description: string;
+  paramsSchema?: z.ZodType<TParams>;
+  load: (params: TParams) => Promise<TData> | TData;
+}
+
+export declare function agent(config: AgentConfig): {
+  stream(options: { messages: Array<{ role: string; content: string }> }): {
+    toDataStreamResponse(): Response;
+  };
+  respond(request: Request): Promise<Response>;
+};
+
+export declare function tool<TInput, TOutput>(config: ToolConfig<TInput, TOutput>): ToolConfig<TInput, TOutput>;
+
+export declare function resource<TParams, TData>(config: ResourceConfig<TParams, TData>): ResourceConfig<TParams, TData>;
+
+// Re-export from ai-sdk
+export * from 'ai';

package/dist/ai/index.js

@@ -1675,7 +1675,7 @@ var BYTES_PER_MB = 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.6",
+  version: "0.0.8",
   nodeModulesDir: "auto",
   workspace: [
     "./examples/async-worker-redis",
@@ -1804,6 +1804,7 @@ var deno_default = {
     dev: "deno run --allow-all --no-lock --unstable-net --unstable-worker-options src/cli/main.ts dev",
     build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
     "build:npm": "deno run -A scripts/build-npm.ts",
+    release: "deno run -A scripts/release.ts",
     test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
     "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
     "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
@@ -3466,6 +3467,7 @@ var DEFAULT_CONFIG2 = {
   }
 };
 var configCacheByProject = /* @__PURE__ */ new Map();
+var cacheRevision = 0;
 function validateCorsConfig(userConfig) {
   if (!userConfig || typeof userConfig !== "object") {
     return;
@@ -3542,13 +3544,18 @@ var ConfigValidationError = class extends Error {
 };
 async function loadAndMergeConfig(configPath, projectDir) {
   try {
-    const configUrl = `file://${configPath}?t=${Date.now()}`;
+    const configUrl = `file://${configPath}?t=${Date.now()}-${crypto.randomUUID()}`;
     const configModule = await import(configUrl);
     const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
     validateCorsConfig(userConfig);
     validateConfigShape(userConfig);
     const merged = mergeConfigs(userConfig);
-    configCacheByProject.set(projectDir, merged);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
     return merged;
   } catch (error) {
     if (error instanceof ConfigValidationError) {
@@ -3562,8 +3569,8 @@ async function loadAndMergeConfig(configPath, projectDir) {
 }
 async function getConfig(projectDir, adapter) {
   const cached = configCacheByProject.get(projectDir);
-  if (cached)
-    return cached;
+  if (cached && cached.revision === cacheRevision)
+    return cached.config;
   const configFiles = ["veryfront.config.js", "veryfront.config.ts", "veryfront.config.mjs"];
   for (const configFile of configFiles) {
     const configPath = join(projectDir, configFile);
@@ -3589,7 +3596,7 @@ async function getConfig(projectDir, adapter) {
     }
   }
   const defaultConfig = DEFAULT_CONFIG2;
-  configCacheByProject.set(projectDir, defaultConfig);
+  configCacheByProject.set(projectDir, { revision: cacheRevision, config: defaultConfig });
   return defaultConfig;
 }
 
@@ -5921,20 +5928,172 @@ var DAGExecutor = class {
         return await this.executeStepNode(node, context);
       case "parallel":
         return await this.executeParallelNode(node, config, context, nodeStates);
+      case "map":
+        return await this.executeMapNode(node, config, context, nodeStates);
       case "branch":
         return await this.executeBranchNode(node, config, context, nodeStates);
       case "wait":
         return await this.executeWaitNode(node, config, context);
       case "subWorkflow":
-        throw new Error(
-          `Sub-workflow execution is not yet implemented for node "${node.id}". Workaround: Flatten your workflow by inlining the sub-workflow steps directly, or use the parallel() or branch() DSL helpers to compose workflows.`
-        );
+        return await this.executeSubWorkflowNode(node, config, context, nodeStates);
       default:
         throw new Error(
-          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, branch, wait, subWorkflow`
+          `Unknown node type "${config.type}" for node "${node.id}". Valid types are: step, parallel, map, branch, wait, subWorkflow`
         );
     }
   }
+  /**
+   * Execute a map node (dynamic fan-out)
+   */
+  async executeMapNode(node, config, context, nodeStates) {
+    const startTime = Date.now();
+    const items = typeof config.items === "function" ? await config.items(context) : config.items;
+    if (!Array.isArray(items)) {
+      throw new Error(`Map node "${node.id}" items must be an array`);
+    }
+    if (items.length === 0) {
+      const state = {
+        nodeId: node.id,
+        status: "completed",
+        output: [],
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: /* @__PURE__ */ new Date()
+      };
+      return { state, contextUpdates: { [node.id]: [] }, waiting: false };
+    }
+    const childNodes = [];
+    const isWorkflowDef = (p) => !!p.steps;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const childId = `${node.id}_${i}`;
+      let childNode;
+      if (isWorkflowDef(config.processor)) {
+        childNode = {
+          id: childId,
+          config: {
+            type: "subWorkflow",
+            workflow: config.processor,
+            input: item,
+            retry: config.retry,
+            checkpoint: false
+            // Don't checkpoint individual map items by default
+          }
+        };
+      } else {
+        const processorConfig = { ...config.processor.config };
+        if (processorConfig.type === "step") {
+          processorConfig.input = item;
+        }
+        childNode = {
+          id: childId,
+          config: processorConfig
+        };
+      }
+      childNodes.push(childNode);
+    }
+    const originalConcurrency = this.config.maxConcurrency;
+    if (config.concurrency) {
+      this.config.maxConcurrency = config.concurrency;
+    }
+    try {
+      const result = await this.execute(childNodes, {
+        id: `${node.id}_map`,
+        workflowId: "",
+        status: "running",
+        input: context.input,
+        nodeStates: {},
+        // Start fresh for map iteration
+        currentNodes: [],
+        context: { ...context },
+        // Pass copy of context so they can read global state
+        checkpoints: [],
+        pendingApprovals: [],
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      Object.assign(nodeStates, result.nodeStates);
+      const outputs = childNodes.map((child) => {
+        const childState = result.nodeStates[child.id];
+        return childState?.output;
+      });
+      const state = {
+        nodeId: node.id,
+        status: result.completed ? "completed" : result.waiting ? "running" : "failed",
+        output: outputs,
+        error: result.error,
+        attempt: 1,
+        startedAt: new Date(startTime),
+        completedAt: result.completed ? /* @__PURE__ */ new Date() : void 0
+      };
+      this.config.onNodeComplete?.(node.id, state);
+      return {
+        state,
+        contextUpdates: result.completed ? { [node.id]: outputs } : {},
+        waiting: result.waiting
+      };
+    } finally {
+      this.config.maxConcurrency = originalConcurrency;
+    }
+  }
+  /**
+   * Execute a sub-workflow node
+   */
+  async executeSubWorkflowNode(node, config, context, nodeStates) {
+    const startTime = Date.now();
+    let workflowDef;
+    if (typeof config.workflow === "string") {
+      throw new Error("Resolving workflow by ID is not yet supported in this execution context. Pass the WorkflowDefinition object.");
+    } else {
+      workflowDef = config.workflow;
+    }
+    const input = typeof config.input === "function" ? await config.input(context) : config.input ?? context.input;
+    let steps;
+    if (typeof workflowDef.steps === "function") {
+      steps = workflowDef.steps({
+        input,
+        context
+      });
+    } else {
+      steps = workflowDef.steps;
+    }
+    const subRunId = `${node.id}_sub_${generateId()}`;
+    const result = await this.execute(steps, {
+      id: subRunId,
+      workflowId: workflowDef.id,
+      status: "running",
+      input,
+      nodeStates: {},
+      currentNodes: [],
+      context: {
+        input
+        // Subworkflow starts with fresh context scoped to its input
+        // We do NOT inherit parent context to ensure isolation, 
+        // unless explicitly passed via input.
+      },
+      checkpoints: [],
+      pendingApprovals: [],
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    let finalOutput = result.context;
+    if (result.completed && config.output) {
+      finalOutput = config.output(result.context);
+    }
+    const state = {
+      nodeId: node.id,
+      status: result.completed ? "completed" : result.waiting ? "running" : "failed",
+      output: finalOutput,
+      error: result.error,
+      attempt: 1,
+      startedAt: new Date(startTime),
+      completedAt: result.completed ? /* @__PURE__ */ new Date() : void 0
+    };
+    this.config.onNodeComplete?.(node.id, state);
+    return {
+      state,
+      contextUpdates: result.completed ? { [node.id]: finalOutput } : {},
+      waiting: result.waiting
+    };
+  }
   /**
    * Execute a step node
    */
@@ -6745,9 +6904,12 @@ var WorkflowExecutor = class _WorkflowExecutor {
     if (Array.isArray(workflow2.steps)) {
       nodes = workflow2.steps;
     } else {
+      if (!this.config.blobStorage) {
+      }
       const builderContext = {
         input: context.input,
-        context
+        context,
+        blobStorage: this.config.blobStorage
       };
       nodes = workflow2.steps(builderContext);
     }