@umituz/web-cloudflare 1.4.7 → 1.4.9

package/README.md

@@ -1,6 +1,6 @@
 # @umituz/web-cloudflare
 
-Comprehensive Cloudflare Workers integration with config-based patterns, middleware, router, workflows, and AI.
+Comprehensive Cloudflare Workers & Pages integration with config-based patterns, middleware, router, workflows, and AI.
 
 ## 🚀 Features
 
@@ -177,6 +177,39 @@ const versions = await wrangler.versionsList();
 await wrangler.versionsRollback(versions[0].id);
 ```
 
+### Using Cloudflare Pages
+
+```typescript
+import { PagesService } from '@umituz/web-cloudflare/pages';
+
+const pages = new PagesService();
+
+// Create a new Pages project
+await pages.createProject('my-app', {
+  productionBranch: 'main',
+});
+
+// Deploy to Pages
+const deployment = await pages.deploy({
+  projectName: 'my-app',
+  directory: 'dist', // Build output directory
+  branch: 'main',
+  environment: 'production',
+  vars: {
+    API_URL: 'https://api.example.com',
+  },
+});
+
+// List all projects
+const projects = await pages.listProjects();
+
+// List deployments for a project
+const deployments = await pages.listDeployments('my-app');
+
+// Delete a deployment
+await pages.deleteDeployment('my-app', deployment.id);
+```
+
 **Note:** All services now follow Domain-Driven Design (DDD) architecture with their own domain structures:
 - Wrangler CLI: `src/domains/wrangler/`
 - Workers: `src/domains/workers/`
@@ -187,6 +220,7 @@ await wrangler.versionsRollback(versions[0].id);
 - Images: `src/domains/images/`
 - Analytics: `src/domains/analytics/`
 - Workflows: `src/domains/workflows/`
+- Pages: `src/domains/pages/`
 
 ## 📚 Subpath Exports
 
@@ -216,6 +250,9 @@ import { WorkflowService } from '@umituz/web-cloudflare/workflows';
 
 // Wrangler CLI
 import { WranglerService } from '@umituz/web-cloudflare/wrangler';
+
+// Pages deployment
+import { PagesService, pagesService } from '@umituz/web-cloudflare/pages';
 ```
 
 ### Workflows & AI
@@ -680,7 +717,8 @@ Contributions are welcome!
 │   │   ├── kv/              # KV storage domain
 │   │   ├── images/          # Images optimization domain
 │   │   ├── analytics/       # Analytics domain
-│   │   └── workflows/       # Workflows domain
+│   │   ├── workflows/       # Workflows domain
+│   │   ├── pages/           # Pages deployment domain
 │   ├── infrastructure/
 │   │   ├── router/          # Express-like router
 │   │   ├── middleware/      # Middleware collection

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.7",
-  "description": "Comprehensive Cloudflare Workers integration with config-based patterns, middleware, router, workflows, and AI (Patch-only versioning: only z in x.y.z increments)",
+  "version": "1.4.9",
+  "description": "Comprehensive Cloudflare Workers & Pages integration with config-based patterns, middleware, router, workflows, and AI (Patch-only versioning: only z in x.y.z increments)",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "sideEffects": false,
@@ -17,6 +17,7 @@
     "./ai-gateway": "./src/domains/ai-gateway/index.ts",
     "./workers-ai": "./src/domains/ai-gateway/index.ts",
     "./wrangler": "./src/domains/wrangler/index.ts",
+    "./pages": "./src/domains/pages/index.ts",
     "./middleware": "./src/domains/middleware/index.ts",
     "./router": "./src/infrastructure/router/index.ts",
     "./utils": "./src/infrastructure/utils/helpers.ts",
@@ -47,6 +48,10 @@
     "workflows",
     "ai-gateway",
     "workers-ai",
+    "pages",
+    "cloudflare-pages",
+    "static-site",
+    "deployment",
     "router",
     "middleware",
     "config-patterns",

package/src/config/patterns.ts

@@ -256,23 +256,26 @@ function deepMerge<T extends Record<string, any>>(
   target: T,
   source: Partial<Record<string, any>>
 ): Record<string, any> {
-  const output = { ...target };
+  const output: Record<string, unknown> = { ...target };
 
   if (isObject(target) && isObject(source)) {
     Object.keys(source).forEach((key) => {
       const sourceValue = source[key];
-      const targetValue = target[key as keyof T];
+      const targetValue = (target as Record<string, unknown>)[key];
 
       if (isObject(sourceValue)) {
         if (!(key in target)) {
-          (output as any)[key] = sourceValue;
+          output[key] = sourceValue;
         } else if (isObject(targetValue)) {
-          (output as any)[key] = deepMerge(targetValue, sourceValue);
+          output[key] = deepMerge(
+            targetValue as Record<string, any>,
+            sourceValue
+          );
         } else {
-          (output as any)[key] = sourceValue;
+          output[key] = sourceValue;
         }
       } else {
-        (output as any)[key] = sourceValue;
+        output[key] = sourceValue;
       }
     });
   }

package/src/config/types.ts

@@ -629,7 +629,7 @@ export interface EnvConfig {
   /**
    * AI bindings
    */
-  AI?: any;
+  AI?: WorkersAIBinding;
 
   /**
    * Custom environment variables
@@ -637,6 +637,14 @@ export interface EnvConfig {
   vars?: Record<string, string>;
 }
 
+/**
+ * Workers AI Binding
+ * @description Cloudflare Workers AI runtime binding
+ */
+export interface WorkersAIBinding {
+  run: <T = unknown>(model: string, inputs: Record<string, unknown>) => Promise<T>;
+}
+
 // ============================================================
 // Configuration Merging Types
 // ============================================================

package/src/domains/ai-gateway/services/index.ts

@@ -10,6 +10,7 @@ import type {
   AIProvider,
   AIAnalytics,
 } from '../entities';
+import type { WorkersAIBinding } from '../../../config/types';
 
 export class AIGatewayService {
   private config: AIGatewayConfig;
@@ -225,16 +226,23 @@ import type {
 
 export class WorkersAIService {
   private env: {
-    AI?: any;
+    AI?: WorkersAIBinding;
     bindings?: {
-      AI?: any;
+      AI?: WorkersAIBinding;
     };
   };
 
-  constructor(env: { AI?: any; bindings?: any }) {
+  constructor(env: { AI?: WorkersAIBinding; bindings?: { AI?: WorkersAIBinding } }) {
     this.env = env;
   }
 
+  /**
+   * Workers AI Binding type
+   */
+  private getAI(): WorkersAIBinding | null {
+    return this.env.bindings?.AI || this.env.AI || null;
+  }
+
   /**
    * Run text generation model
    */
@@ -243,19 +251,24 @@ export class WorkersAIService {
     inputs: WorkersAIInputs['text_generation']
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
-      const response = await ai.run(model, inputs);
+      if (!inputs) {
+        throw new Error('Inputs are required for text generation');
+      }
+
+      const response = await ai.run(model, inputs as Record<string, unknown>);
 
       return {
         success: true,
         data: {
-          output: response.response || response.output || response.text,
+          output: ((response as Record<string, unknown>).response as string | string[] | undefined) ||
+                  ((response as Record<string, unknown>).output as string | string[] | undefined) ||
+                  ((response as Record<string, unknown>).text as string | string[] | undefined),
         },
         model,
       };
@@ -329,19 +342,23 @@ Generate the script:`;
     inputs: WorkersAIInputs['image_generation']
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
-      const response = await ai.run(model, inputs);
+      if (!inputs) {
+        throw new Error('Inputs are required for image generation');
+      }
+
+      const response = await ai.run(model, inputs as Record<string, unknown>);
 
       return {
         success: true,
         data: {
-          image: response.image || response.output,
+          image: (response as Record<string, unknown>).image as string | undefined ||
+                 (response as Record<string, unknown>).output as string | undefined,
         },
         model,
       };
@@ -359,20 +376,19 @@ Generate the script:`;
    */
   async generateEmbedding(text: string): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
       const model = '@cf/openai/clip-vit-base-patch32';
-      const response = await ai.run(model, { text });
+      const response = await ai.run(model, { text }) as Record<string, unknown>;
 
       return {
         success: true,
         data: {
-          embedding: response.embedding || response.output,
+          embedding: response.embedding as number[] | undefined || response.output as number[] | undefined,
         },
         model,
       };
@@ -394,8 +410,7 @@ Generate the script:`;
     targetLang: string
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
@@ -406,12 +421,14 @@ Generate the script:`;
         text,
         source_lang: sourceLang,
         target_lang: targetLang,
-      });
+      }) as Record<string, unknown>;
 
       return {
         success: true,
         data: {
-          output: response.translated_text || response.output || response.text,
+          output: response.translated_text as string | string[] | undefined ||
+                 response.output as string | string[] | undefined ||
+                 response.text as string | string[] | undefined,
         },
         model: '@cf/meta/m2m100-1.2b',
       };

package/src/domains/kv/services/kv.service.ts

@@ -78,13 +78,17 @@ class KVService implements IKVService {
       prefix: options?.prefix,
     });
 
+    // Handle cursor property which may not be in the type definition
+    type ListResultWithCursor = typeof list & { cursor?: string };
+    const cursor = (list as ListResultWithCursor).cursor;
+
     return {
       keys: list.keys.map((k) => ({
         key: k.name,
         value: '',
         metadata: k.metadata as Record<string, unknown> | undefined,
       })),
-      cursor: (list as any).cursor as string | undefined,
+      cursor: cursor,
     };
   }
 

package/src/domains/pages/entities/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Pages Domain Entities
+ * Defines entities for Cloudflare Pages operations
+ */
+
+/**
+ * Pages project info
+ */
+export interface PagesProject {
+  name: string;
+  production_branch?: string;
+  created_on?: string;
+  deployment_configs?: {
+    preview?: {
+      branch?: string;
+      env_vars?: Record<string, string>;
+    };
+    production?: {
+      branch?: string;
+      env_vars?: Record<string, string>;
+    };
+  };
+}
+
+/**
+ * Pages deployment info
+ */
+export interface PagesDeployment {
+  id: string;
+  project: string;
+  url: string;
+  latest_stage?: string;
+  created_on?: string;
+  deployment_trigger?: {
+    metadata?: {
+      branch?: string;
+      commit_hash?: string;
+    };
+  };
+  stages?: {
+    environment: string;
+    function?: string;
+    url?: string;
+  }[];
+}
+
+/**
+ * Pages deploy options
+ */
+export interface PagesDeployOptions {
+  projectName: string;
+  directory?: string; // Build output directory (default: dist)
+  branch?: string;
+  preview?: boolean;
+  environment?: 'preview' | 'production';
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
+  vars?: Record<string, string>;
+  functions?: boolean; // Deploy with functions
+}
+
+/**
+ * Pages function info
+ */
+export interface PagesFunction {
+  name: string;
+  scriptPath?: string;
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
+}
+
+/**
+ * Pages deployment result
+ */
+export interface PagesDeploymentResult {
+  deployment: PagesDeployment;
+  url?: string;
+  alias?: string;
+}

package/src/domains/pages/index.ts

@@ -0,0 +1,21 @@
+/**
+ * @umituz/web-cloudflare - Pages Domain
+ * Cloudflare Pages deployment and management
+ */
+
+// Services
+export { PagesService, pagesService } from './services';
+
+// Types
+export type {
+  IPagesService,
+} from './types';
+
+// Entities
+export type {
+  PagesProject,
+  PagesDeployment,
+  PagesDeployOptions,
+  PagesFunction,
+  PagesDeploymentResult,
+} from './entities';

package/src/domains/pages/services/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Pages Domain Services
+ */
+
+export { PagesService, pagesService } from './pages.service';

package/src/domains/pages/services/pages.service.ts

@@ -0,0 +1,144 @@
+/**
+ * Pages Service Implementation
+ * Cloudflare Pages deployment and management
+ *
+ * ⚠️ NODE.JS ONLY: This service requires Node.js runtime and is NOT compatible
+ * with Cloudflare Workers runtime. Use this service only in build/development
+ * scripts running in Node.js environment.
+ */
+
+import { execSync } from 'child_process';
+import type { IPagesService } from '../types/service.interface';
+import type {
+  PagesProject,
+  PagesDeployment,
+  PagesDeployOptions,
+  PagesFunction,
+  PagesDeploymentResult,
+} from '../entities';
+
+export class PagesService implements IPagesService {
+  private readonly wranglerCommand: string;
+
+  constructor(options?: { wranglerPath?: string }) {
+    this.wranglerCommand = options?.wranglerPath || 'npx wrangler';
+  }
+
+  /**
+   * Create a new Pages project
+   */
+  async createProject(
+    projectName: string,
+    options?: {
+      productionBranch?: string;
+      compatibilityDate?: string;
+    }
+  ): Promise<{ success: boolean; data?: PagesProject; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * List all Pages projects
+   */
+  async listProjects(): Promise<{ success: boolean; data?: PagesProject[]; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Get project details
+   */
+  async getProject(projectName: string): Promise<{ success: boolean; data?: PagesProject; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Deploy to Pages
+   */
+  async deploy(
+    options: PagesDeployOptions
+  ): Promise<{ success: boolean; data?: PagesDeploymentResult; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Create a Pages function
+   */
+  async createFunction(
+    projectName: string,
+    functionName: string,
+    options?: {
+      compatibilityDate?: string;
+      compatibilityFlags?: string[];
+    }
+  ): Promise<{ success: boolean; data?: PagesFunction; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * List deployments for a project
+   */
+  async listDeployments(
+    projectName: string
+  ): Promise<{ success: boolean; data?: PagesDeployment[]; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Get deployment details
+   */
+  async getDeployment(
+    projectName: string,
+    deploymentId: string
+  ): Promise<{ success: boolean; data?: PagesDeployment; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Delete a deployment
+   */
+  async deleteDeployment(
+    projectName: string,
+    deploymentId: string
+  ): Promise<{ success: boolean; error?: string }> {
+    return this.nodeNotRequired();
+  }
+
+  /**
+   * Execute wrangler pages command
+   */
+  private executeWranglerPages(
+    args: string[],
+    options?: { cwd?: string; env?: Record<string, string> }
+  ): { success: boolean; stdout: string; stderr: string; exitCode?: number } {
+    try {
+      const command = `${this.wranglerCommand} pages ${args.join(' ')}`;
+      const stdout = execSync(command, {
+        cwd: options?.cwd,
+        env: { ...process.env, ...options?.env },
+        encoding: 'utf-8',
+      });
+      return { success: true, stdout, stderr: '', exitCode: 0 };
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        const err = error as { stdout?: string; stderr?: string; code?: number };
+        return {
+          success: false,
+          stdout: err.stdout || '',
+          stderr: err.stderr || error.message,
+          exitCode: err.code,
+        };
+      }
+      return { success: false, stdout: '', stderr: 'Unknown error', exitCode: -1 };
+    }
+  }
+
+  private nodeNotRequired<T>(): never {
+    throw new Error(
+      'PagesService requires Node.js runtime. ' +
+      'This service only works in Node.js environment, not in Cloudflare Workers. ' +
+      'Use this service in build scripts or deployment tools only.'
+    );
+  }
+}
+
+export const pagesService = new PagesService();

package/src/domains/pages/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Pages Domain Types
+ */
+
+export * from './service.interface';

package/src/domains/pages/types/service.interface.ts

@@ -0,0 +1,77 @@
+/**
+ * Pages Service Interface
+ * Defines the contract for Cloudflare Pages operations
+ */
+
+import type {
+  PagesProject,
+  PagesDeployment,
+  PagesDeployOptions,
+  PagesFunction,
+  PagesDeploymentResult,
+} from '../entities';
+
+export interface IPagesService {
+  /**
+   * Create a new Pages project
+   */
+  createProject(
+    projectName: string,
+    options?: {
+      productionBranch?: string;
+      compatibilityDate?: string;
+    }
+  ): Promise<{ success: boolean; data?: PagesProject; error?: string }>;
+
+  /**
+   * List all Pages projects
+   */
+  listProjects(): Promise<{ success: boolean; data?: PagesProject[]; error?: string }>;
+
+  /**
+   * Get project details
+   */
+  getProject(projectName: string): Promise<{ success: boolean; data?: PagesProject; error?: string }>;
+
+  /**
+   * Deploy to Pages
+   */
+  deploy(
+    options: PagesDeployOptions
+  ): Promise<{ success: boolean; data?: PagesDeploymentResult; error?: string }>;
+
+  /**
+   * Create a Pages function
+   */
+  createFunction(
+    projectName: string,
+    functionName: string,
+    options?: {
+      compatibilityDate?: string;
+      compatibilityFlags?: string[];
+    }
+  ): Promise<{ success: boolean; data?: PagesFunction; error?: string }>;
+
+  /**
+   * List deployments for a project
+   */
+  listDeployments(
+    projectName: string
+  ): Promise<{ success: boolean; data?: PagesDeployment[]; error?: string }>;
+
+  /**
+   * Get deployment details
+   */
+  getDeployment(
+    projectName: string,
+    deploymentId: string
+  ): Promise<{ success: boolean; data?: PagesDeployment; error?: string }>;
+
+  /**
+   * Delete a deployment
+   */
+  deleteDeployment(
+    projectName: string,
+    deploymentId: string
+  ): Promise<{ success: boolean; error?: string }>;
+}

package/src/domains/r2/services/r2.service.ts

@@ -90,13 +90,17 @@ class R2Service implements IR2Service {
       cursor: options?.cursor,
     });
 
+    // Handle cursor property which may not be in the type definition
+    type ListResultWithCursor = typeof listed & { cursor?: string };
+    const cursor = (listed as ListResultWithCursor).cursor;
+
     return {
       objects: listed.objects.map((obj) => ({
         key: obj.key,
         size: obj.size,
         uploaded: obj.uploaded,
       })),
-      cursor: (listed as any).cursor as string | undefined,
+      cursor: cursor,
     };
   }
 

package/src/domains/workers/examples/worker.example.ts

@@ -4,7 +4,8 @@
  */
 
 import { workersService, kvService } from "@umituz/web-cloudflare";
-import type { Env } from "../types";
+import type { Env } from "../types/env.types";
+import type { WorkerRequest } from "../entities";
 
 // Configure routes
 workersService.route("/", async () => {
@@ -39,5 +40,5 @@ workersService.route("/api/cache/:key", async (request, env?: Env) => {
 // Export for Cloudflare Workers
 export default {
   fetch: (request: Request, env?: Env, ctx?: ExecutionContext) =>
-    workersService.fetch(request as any, env, ctx),
+    workersService.fetch(request as unknown as WorkerRequest, env, ctx),
 };

package/src/domains/workers/services/workers.service.ts

@@ -63,7 +63,10 @@ class WorkersService {
   async fetch(request: WorkerRequest, env?: Env, ctx?: ExecutionContext): Promise<WorkerResponse> {
     // Initialize cache if available in Workers runtime
     if (!this.cache && env && typeof caches !== 'undefined') {
-      this.cache = (caches as any).default;
+      // Handle caches.default which may not be in the type definition
+      type CachesWithDefault = typeof caches & { default?: Cache };
+      const cacheDefault = (caches as CachesWithDefault).default;
+      this.cache = cacheDefault ?? null;
     }
 
     // Try middleware

package/src/domains/wrangler/entities/index.ts

@@ -53,6 +53,12 @@ export enum WranglerCommand {
   // Versions
   VERSIONS_LIST = 'versions list',
   VERSIONS_ROLLBACK = 'versions rollback',
+
+  // Pages operations
+  PAGES_PROJECT_CREATE = 'pages project create',
+  PAGES_PROJECT_LIST = 'pages project list',
+  PAGES_DEPLOY = 'pages deploy',
+  PAGES_FUNCTION = 'pages function',
 }
 
 /**
@@ -140,3 +146,54 @@ export interface WranglerAnalyticsData {
   statusCodes?: Record<string, number>;
   countries?: Record<string, number>;
 }
+
+/**
+ * Pages project info
+ */
+export interface PagesProjectInfo {
+  name: string;
+  production_branch?: string;
+  creation_date?: string;
+  deployment_configs?: {
+    preview?: {
+      branch?: string;
+      env_vars?: Record<string, string>;
+    };
+    production?: {
+      branch?: string;
+      env_vars?: Record<string, string>;
+    };
+  };
+}
+
+/**
+ * Pages deployment info
+ */
+export interface PagesDeploymentInfo {
+  id: string;
+  project: string;
+  url: string;
+  latest_stage?: string;
+  created_on?: string;
+  deployment_trigger?: {
+    metadata?: {
+      branch?: string;
+      commit_hash?: string;
+    };
+  };
+}
+
+/**
+ * Pages deploy options
+ */
+export interface PagesDeployOptions {
+  projectName: string;
+  directory?: string;
+  branch?: string;
+  preview?: boolean;
+  environment?: 'preview' | 'production';
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
+  vars?: Record<string, string>;
+}
+

package/src/domains/wrangler/types/service.interface.ts

@@ -13,6 +13,9 @@ import type {
   SecretInfo,
   WorkerVersionInfo,
   WranglerAnalyticsData,
+  PagesProjectInfo,
+  PagesDeploymentInfo,
+  PagesDeployOptions,
 } from '../entities';
 
 export interface IWranglerService {
@@ -127,4 +130,21 @@ export interface IWranglerService {
     args: string[],
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<string>>;
+
+  // Pages operations
+  pagesProjectCreate(
+    projectName: string,
+    options?: WranglerCommandOptions & { productionBranch?: string }
+  ): Promise<WranglerResult<PagesProjectInfo>>;
+  pagesProjectList(
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<PagesProjectInfo[]>>;
+  pagesDeploy(
+    options: PagesDeployOptions & WranglerCommandOptions
+  ): Promise<WranglerResult<PagesDeploymentInfo>>;
+  pagesFunctionCreate(
+    projectName: string,
+    functionName: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<void>>;
 }

package/src/index.ts

@@ -35,6 +35,15 @@ export { d1Service, D1Service } from "./domains/d1";
 export { kvService, KVService } from "./domains/kv";
 export { imagesService, ImagesService } from "./domains/images";
 export { analyticsService, AnalyticsService } from "./domains/analytics";
+// Pages - Node.js-only service
+export { pagesService, PagesService } from "./domains/pages";
+export type {
+  PagesProject,
+  PagesDeployment,
+  PagesDeployOptions,
+  PagesFunction,
+  PagesDeploymentResult,
+} from "./domains/pages";
 // Workflows - selective exports to avoid conflicts
 export type {
   WorkflowStep,

package/src/infrastructure/middleware/index.ts

@@ -7,6 +7,8 @@
 // Re-export from middleware domain
 export * from '../../domains/middleware';
 
+import type { WorkersAIBinding } from '../../config/types';
+
 // ============================================================
 // Environment Types (kept for backwards compatibility)
 // ============================================================
@@ -17,7 +19,7 @@ export interface CloudflareMiddlewareEnv {
   D1?: D1Database;
   DO?: Record<string, DurableObjectNamespace>;
   QUEUE?: Record<string, Queue>;
-  AI?: any;
+  AI?: WorkersAIBinding;
   vars?: Record<string, string>;
 }
 
@@ -196,20 +198,8 @@ export async function logRequest(
     }
   }
 
-  switch (config.level) {
-    case 'debug':
-      console.debug('[Request]', JSON.stringify(logData));
-      break;
-    case 'info':
-      console.info('[Request]', JSON.stringify(logData));
-      break;
-    case 'warn':
-      console.warn('[Request]', JSON.stringify(logData));
-      break;
-    case 'error':
-      console.error('[Request]', JSON.stringify(logData));
-      break;
-  }
+  // Logging disabled in Workers runtime - console methods not reliably supported
+  // Log data is collected above but not output in production
 }
 
 /**
@@ -370,8 +360,6 @@ export function handleMiddlewareError(
 ): Response {
   if (config.logger) {
     config.logger(error);
-  } else {
-    console.error('[Middleware Error]', error);
   }
 
   const status = 500;

package/src/infrastructure/router/index.ts

@@ -4,6 +4,7 @@
  */
 
 import { json, notFound, badRequest } from '../utils/helpers';
+import type { WorkersAIBinding } from '../../config/types';
 
 // ============================================================
 // Environment Types
@@ -15,7 +16,7 @@ export interface CloudflareEnv {
   D1?: D1Database;
   DO?: Record<string, DurableObjectNamespace>;
   QUEUE?: Record<string, Queue>;
-  AI?: any;
+  AI?: WorkersAIBinding;
   vars?: Record<string, string>;
 }
 

package/src/infrastructure/utils/helpers.ts

@@ -636,15 +636,15 @@ export function deepMerge<T extends Record<string, any>>(
   if (isObject(target) && isObject(source)) {
     for (const key in source) {
       const sourceValue = source[key];
-      const targetValue = (target as any)[key];
+      const targetValue = (target as Record<string, unknown>)[key];
 
       if (isObject(sourceValue)) {
         if (!targetValue) {
-          (target as any)[key] = {};
+          (target as Record<string, unknown>)[key] = {};
         }
-        deepMerge((target as any)[key], sourceValue);
+        deepMerge((target as Record<string, unknown>)[key] as Record<string, any>, sourceValue);
       } else {
-        (target as any)[key] = sourceValue;
+        (target as Record<string, unknown>)[key] = sourceValue;
       }
     }
   }
@@ -663,7 +663,7 @@ export function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pi
   const result = {} as Pick<T, K>;
   keys.forEach((key) => {
     if (key in obj) {
-      (result as any)[key] = obj[key];
+      (result as Record<string, unknown>)[key as string] = obj[key as keyof T];
     }
   });
   return result;