Cloudflare Workers Performance

Cloudflare Workers Performance Optimization

Techniques for maximizing Worker performance and minimizing latency.

Quick Wins

// 1. Avoid unnecessary cloning
// ❌ Bad: Clones entire request
const body = await request.clone().json();

// ✅ Good: Parse directly when not re-using body
const body = await request.json();

// 2. Use streaming instead of buffering
// ❌ Bad: Buffers entire response
const text = await response.text();
return new Response(transform(text));

// ✅ Good: Stream transformation
return new Response(response.body.pipeThrough(new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(process(chunk));
  }
})));

// 3. Cache expensive operations
const cache = caches.default;
const cached = await cache.match(request);
if (cached) return cached;

Critical Rules

1. Stay under CPU limits - 10ms (free), 30ms (paid), 50ms (unbound) 2. Minimize cold starts - Keep bundles < 1MB, avoid dynamic imports 3. Use Cache API - Cache responses at the edge 4. Stream large payloads - Don't buffer entire responses 5. Batch operations - Combine multiple KV/D1 calls

Top 10 Performance Errors

CPU Optimization

Profile Hot Paths

async function profiledHandler(request: Request): Promise<Response> {
  const timing: Record<string, number> = {};

  const time = async <T>(name: string, fn: () => Promise<T>): Promise<T> => {
    const start = Date.now();
    const result = await fn();
    timing[name] = Date.now() - start;
    return result;
  };

  const data = await time('fetch', () => fetchData());
  const processed = await time('process', () => processData(data));
  const response = await time('serialize', () => serialize(processed));

  console.log('Timing:', timing);
  return new Response(response);
}

Optimize JSON Operations

// For large JSON, use streaming parser
import { JSONParser } from '@streamparser/json';

async function parseStreamingJSON(stream: ReadableStream): Promise<unknown[]> {
  const parser = new JSONParser();
  const results: unknown[] = [];

  parser.onValue = (value) => results.push(value);

  for await (const chunk of stream) {
    parser.write(chunk);
  }

  return results;
}

Memory Optimization

Avoid Large Arrays

// ❌ Bad: Loads all into memory
const items = await db.prepare('SELECT * FROM items').all();
const processed = items.results.map(transform);

// ✅ Good: Process in batches
async function* batchProcess(db: D1Database, batchSize = 100) {
  let offset = 0;
  while (true) {
    const { results } = await db
      .prepare('SELECT * FROM items LIMIT ? OFFSET ?')
      .bind(batchSize, offset)
      .all();

    if (results.length === 0) break;

    for (const item of results) {
      yield transform(item);
    }
    offset += batchSize;
  }
}

Caching Strategies

Multi-Layer Cache

interface CacheLayer {
  get(key: string): Promise<unknown | null>;
  set(key: string, value: unknown, ttl?: number): Promise<void>;
}

// Layer 1: In-memory (request-scoped)
const memoryCache = new Map<string, unknown>();

// Layer 2: Cache API (edge-local)
const edgeCache: CacheLayer = {
  async get(key) {
    const response = await caches.default.match(new Request(`https://cache/${key}`));
    return response ? response.json() : null;
  },
  async set(key, value, ttl = 60) {
    await caches.default.put(
      new Request(`https://cache/${key}`),
      new Response(JSON.stringify(value), {
        headers: { 'Cache-Control': `max-age=${ttl}` }
      })
    );
  }
};

// Layer 3: KV (global)
// Use env.KV.get/put

Bundle Optimization

// 1. Tree-shake imports
// ❌ Bad
import * as lodash from 'lodash';

// ✅ Good
import { debounce } from 'lodash-es';

// 2. Lazy load heavy dependencies
let heavyLib: typeof import('heavy-lib') | undefined;

async function getHeavyLib() {
  if (!heavyLib) {
    heavyLib = await import('heavy-lib');
  }
  return heavyLib;
}

When to Load References

Load specific references based on the task:

• Optimizing CPU usage? → Load references/cpu-optimization.md
• Memory issues? → Load references/memory-optimization.md
• Implementing caching? → Load references/caching-strategies.md
• Reducing bundle size? → Load references/bundle-optimization.md
• Cold start problems? → Load references/cold-starts.md

Templates

Scripts

Resources

• Performance: https://developers.cloudflare.com/workers/platform/performance/
• Limits: https://developers.cloudflare.com/workers/platform/limits/
• Caching: https://developers.cloudflare.com/workers/runtime-apis/cache/

Bundle Optimization for Cloudflare Workers

Techniques for minimizing bundle size and improving cold start performance.

Bundle Limits

Larger bundles = slower cold starts. Target < 1 MB for best performance.

Analyzing Bundle Size

Using Wrangler

# Build and show size
bunx wrangler deploy --dry-run --outdir dist

# Check compressed size
du -h dist/index.js
gzip -c dist/index.js | wc -c

Bundle Analyzer

// vite.config.ts for analysis
import { defineConfig } from 'vite';
import { visualizer } from 'rollup-plugin-visualizer';

export default defineConfig({
  build: {
    rollupOptions: {
      plugins: [
        visualizer({
          filename: 'bundle-stats.html',
          gzipSize: true,
          brotliSize: true,
        }),
      ],
    },
  },
});

Size Tracking Script

// scripts/check-bundle-size.ts
import { readFileSync, statSync } from 'fs';
import { gzipSync } from 'zlib';

const MAX_SIZE_KB = 500; // Target max size

function checkBundleSize(path: string): void {
  const content = readFileSync(path);
  const compressed = gzipSync(content);

  const rawKB = content.length / 1024;
  const gzipKB = compressed.length / 1024;

  console.log(`Bundle: ${path}`);
  console.log(`  Raw: ${rawKB.toFixed(2)} KB`);
  console.log(`  Gzip: ${gzipKB.toFixed(2)} KB`);

  if (gzipKB > MAX_SIZE_KB) {
    console.error(`  ⚠️  Exceeds target of ${MAX_SIZE_KB} KB!`);
    process.exit(1);
  } else {
    console.log(`  ✓ Within target`);
  }
}

checkBundleSize('dist/index.js');

Tree Shaking

Import Only What You Need

// ❌ Bad: Imports entire library
import * as lodash from 'lodash';
const result = lodash.debounce(fn, 100);

// ✅ Good: Import specific function
import debounce from 'lodash-es/debounce';
const result = debounce(fn, 100);

// ✅ Even better: Use native or lightweight alternative
function debounce<T extends (...args: unknown[]) => unknown>(
  fn: T,
  ms: number
): T {
  let timeout: ReturnType<typeof setTimeout>;
  return ((...args) => {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn(...args), ms);
  }) as T;
}

Mark Side Effects

// package.json - helps bundler with tree shaking
{
  "sideEffects": false,
  // or specify files with side effects
  "sideEffects": ["*.css", "./src/polyfills.ts"]
}

Named Exports for Better Tree Shaking

// ❌ Bad: Default export object
export default {
  functionA,
  functionB,
  functionC,
};

// ✅ Good: Named exports
export { functionA, functionB, functionC };

Code Splitting

Dynamic Imports

// Heavy code loaded only when needed
async function processImage(image: ArrayBuffer): Promise<ArrayBuffer> {
  // Only load image processing when needed
  const { processImage } = await import('./heavy-image-lib');
  return processImage(image);
}

// Route-based splitting
const routes: Record<string, () => Promise<{ default: Handler }>> = {
  '/api/images': () => import('./handlers/images'),
  '/api/pdf': () => import('./handlers/pdf'),
  '/api/export': () => import('./handlers/export'),
};

export default {
  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);

    for (const [path, loader] of Object.entries(routes)) {
      if (url.pathname.startsWith(path)) {
        const { default: handler } = await loader();
        return handler(request);
      }
    }

    return new Response('Not Found', { status: 404 });
  }
};

Feature Flags for Conditional Loading

interface Env {
  ENABLE_AI: string;
  ENABLE_ANALYTICS: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Only load AI module if enabled
    if (env.ENABLE_AI === 'true') {
      const ai = await import('./features/ai');
      // Use AI features
    }

    // Only load analytics if enabled
    if (env.ENABLE_ANALYTICS === 'true') {
      const analytics = await import('./features/analytics');
      // Use analytics
    }

    return handleRequest(request);
  }
};

Dependency Optimization

Lightweight Alternatives

Audit Dependencies

# Check bundle contribution of each package
npx bundle-buddy dist/stats.json

# Find unused dependencies
npx depcheck

# Check for duplicates
npx npm-dedupe

External Dependencies

// wrangler.jsonc - exclude from bundle
{
  "build": {
    "command": "bun run build"
  },
  "rules": [
    {
      "type": "ESModule",
      "globs": ["**/*.js"],
      "fallthrough": true
    }
  ]
}

Minification

Configure Minification

// vite.config.ts
import { defineConfig } from 'vite';

export default defineConfig({
  build: {
    minify: 'terser',
    terserOptions: {
      compress: {
        passes: 2,
        drop_console: true, // Remove console.log in production
        drop_debugger: true,
        pure_funcs: ['console.log', 'console.debug'],
      },
      mangle: true,
    },
  },
});

Remove Dead Code

// Use environment flags
const IS_DEV = process.env.NODE_ENV === 'development';

function debug(...args: unknown[]): void {
  if (IS_DEV) {
    console.log('[DEBUG]', ...args);
  }
}

// After minification with dead code elimination:
// debug() calls are completely removed in production

Compression

Pre-compress Assets

# Gzip compression
gzip -k -9 dist/index.js

# Brotli compression (better)
brotli -k -q 11 dist/index.js

Optimize for Compression

// Compression-friendly patterns

// ❌ Bad: Unique strings
const errors = {
  E001: 'Invalid user input',
  E002: 'Database connection failed',
  E003: 'Authentication required',
};

// ✅ Good: Repetitive patterns compress better
const ERROR_PREFIX = 'Error: ';
const errors = {
  E001: ERROR_PREFIX + 'Invalid user input',
  E002: ERROR_PREFIX + 'Database connection failed',
  E003: ERROR_PREFIX + 'Authentication required',
};

Asset Optimization

Inline Small Assets

// Inline small SVGs instead of importing
const ArrowIcon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
  <path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z"/>
</svg>`;

// Use data URLs for tiny images (< 1KB)
const tinyImage = 'data:image/png;base64,iVBORw0KGgo...';

Optimize JSON Data

// ❌ Bad: Verbose JSON
const config = {
  "enableFeatureA": true,
  "enableFeatureB": false,
  "maxRetries": 3,
  "timeout": 5000,
};

// ✅ Good: Compact representation
const config = { a: 1, b: 0, r: 3, t: 5000 };

// Or use binary format for large data
const binaryConfig = new Uint8Array([1, 0, 3, 0, 0, 19, 136]); // Packed

Build Pipeline

Optimized Build Script

{
  "scripts": {
    "build": "bun run build:bundle && bun run build:analyze",
    "build:bundle": "esbuild src/index.ts --bundle --minify --format=esm --outfile=dist/index.js",
    "build:analyze": "bun scripts/check-bundle-size.ts",
    "build:watch": "esbuild src/index.ts --bundle --format=esm --outfile=dist/index.js --watch"
  }
}

ESBuild Configuration

// build.ts
import * as esbuild from 'esbuild';

await esbuild.build({
  entryPoints: ['src/index.ts'],
  bundle: true,
  minify: true,
  format: 'esm',
  target: 'es2022',
  platform: 'browser',
  outfile: 'dist/index.js',
  treeShaking: true,
  drop: ['console', 'debugger'],
  define: {
    'process.env.NODE_ENV': '"production"',
  },
  external: [
    // Cloudflare-provided modules
    'cloudflare:email',
    'cloudflare:sockets',
  ],
});

Monitoring Bundle Size

CI Check

# .github/workflows/bundle-check.yml
name: Bundle Size Check

on: [push, pull_request]

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v1

      - run: bun install
      - run: bun run build

      - name: Check bundle size
        run: |
          SIZE=$(gzip -c dist/index.js | wc -c)
          echo "Bundle size: $SIZE bytes"
          if [ $SIZE -gt 512000 ]; then
            echo "Bundle exceeds 500KB limit!"
            exit 1
          fi

Caching Strategies for Cloudflare Workers

Comprehensive guide to caching at the edge for maximum performance.

Cache Layers

Request → Memory Cache → Edge Cache (Cache API) → KV → Origin
           (fastest)      (per-colo)              (global)  (slowest)

Cache API

Basic Usage

const cache = caches.default;

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Check cache
    const cached = await cache.match(request);
    if (cached) {
      return cached;
    }

    // Generate response
    const response = await generateResponse(request, env);

    // Cache response (non-blocking)
    const cacheableResponse = new Response(response.body, response);
    cacheableResponse.headers.set('Cache-Control', 'max-age=3600');

    // Don't await - cache in background
    cache.put(request, cacheableResponse.clone());

    return response;
  }
};

Custom Cache Keys

function getCacheKey(request: Request): Request {
  const url = new URL(request.url);

  // Normalize URL
  url.searchParams.sort();

  // Remove tracking params
  url.searchParams.delete('utm_source');
  url.searchParams.delete('utm_medium');
  url.searchParams.delete('utm_campaign');

  // Include important headers in key
  const headers = new Headers();
  headers.set('Accept', request.headers.get('Accept') || '*/*');

  return new Request(url.toString(), {
    method: 'GET',
    headers,
  });
}

// Usage
const cacheKey = getCacheKey(request);
const cached = await cache.match(cacheKey);

Vary-Based Caching

async function cacheWithVary(
  request: Request,
  response: Response,
  varyHeaders: string[]
): Promise<void> {
  const cache = caches.default;

  // Create unique cache key based on Vary headers
  const url = new URL(request.url);

  for (const header of varyHeaders) {
    const value = request.headers.get(header);
    if (value) {
      url.searchParams.set(`_vary_${header}`, value);
    }
  }

  const cacheKey = new Request(url.toString());
  const cacheableResponse = new Response(response.body, response);
  cacheableResponse.headers.set('Vary', varyHeaders.join(', '));

  await cache.put(cacheKey, cacheableResponse);
}

Stale-While-Revalidate

interface SWROptions {
  cache: Cache;
  maxAge: number;
  staleWhileRevalidate: number;
}

async function fetchWithSWR(
  request: Request,
  fetcher: () => Promise<Response>,
  options: SWROptions
): Promise<Response> {
  const { cache, maxAge, staleWhileRevalidate } = options;

  const cached = await cache.match(request);

  if (cached) {
    const age = getAge(cached);

    // Fresh - return immediately
    if (age < maxAge) {
      return cached;
    }

    // Stale but within revalidate window
    if (age < maxAge + staleWhileRevalidate) {
      // Return stale, revalidate in background
      revalidate(request, fetcher, cache, maxAge);
      return cached;
    }
  }

  // No cache or too stale - fetch fresh
  const response = await fetcher();
  await cacheResponse(request, response.clone(), cache, maxAge);
  return response;
}

function getAge(response: Response): number {
  const date = response.headers.get('Date');
  if (!date) return Infinity;

  return (Date.now() - new Date(date).getTime()) / 1000;
}

async function revalidate(
  request: Request,
  fetcher: () => Promise<Response>,
  cache: Cache,
  maxAge: number
): Promise<void> {
  try {
    const response = await fetcher();
    await cacheResponse(request, response, cache, maxAge);
  } catch {
    // Keep serving stale on revalidation failure
  }
}

async function cacheResponse(
  request: Request,
  response: Response,
  cache: Cache,
  maxAge: number
): Promise<void> {
  const cached = new Response(response.body, response);
  cached.headers.set('Cache-Control', `max-age=${maxAge}`);
  cached.headers.set('Date', new Date().toUTCString());
  await cache.put(request, cached);
}

KV-Based Caching

Simple KV Cache

interface CacheEntry<T> {
  data: T;
  timestamp: number;
  ttl: number;
}

class KVCache<T> {
  constructor(
    private kv: KVNamespace,
    private prefix = 'cache:'
  ) {}

  async get(key: string): Promise<T | null> {
    const entry = await this.kv.get<CacheEntry<T>>(
      this.prefix + key,
      'json'
    );

    if (!entry) return null;

    // Check expiration
    if (Date.now() > entry.timestamp + entry.ttl * 1000) {
      // Expired - delete in background
      this.kv.delete(this.prefix + key);
      return null;
    }

    return entry.data;
  }

  async set(key: string, data: T, ttlSeconds = 3600): Promise<void> {
    const entry: CacheEntry<T> = {
      data,
      timestamp: Date.now(),
      ttl: ttlSeconds,
    };

    await this.kv.put(this.prefix + key, JSON.stringify(entry), {
      expirationTtl: ttlSeconds,
    });
  }

  async delete(key: string): Promise<void> {
    await this.kv.delete(this.prefix + key);
  }
}

Cache-Aside Pattern

class CacheAside<T> {
  constructor(
    private cache: KVCache<T>,
    private ttl: number
  ) {}

  async get(
    key: string,
    fetcher: () => Promise<T>
  ): Promise<T> {
    // Try cache first
    const cached = await this.cache.get(key);
    if (cached !== null) {
      return cached;
    }

    // Cache miss - fetch data
    const data = await fetcher();

    // Store in cache (non-blocking)
    this.cache.set(key, data, this.ttl);

    return data;
  }

  async invalidate(key: string): Promise<void> {
    await this.cache.delete(key);
  }
}

// Usage
const userCache = new CacheAside<User>(kvCache, 3600);

const user = await userCache.get(`user:${userId}`, async () => {
  return db.prepare('SELECT * FROM users WHERE id = ?').bind(userId).first();
});

Multi-Layer Cache

interface CacheLayer<T> {
  get(key: string): Promise<T | null>;
  set(key: string, value: T, ttl?: number): Promise<void>;
}

class MultiLayerCache<T> {
  private layers: CacheLayer<T>[];

  constructor(layers: CacheLayer<T>[]) {
    this.layers = layers;
  }

  async get(key: string): Promise<T | null> {
    for (let i = 0; i < this.layers.length; i++) {
      const value = await this.layers[i].get(key);

      if (value !== null) {
        // Populate upper layers
        for (let j = 0; j < i; j++) {
          this.layers[j].set(key, value);
        }
        return value;
      }
    }

    return null;
  }

  async set(key: string, value: T, ttl?: number): Promise<void> {
    await Promise.all(
      this.layers.map(layer => layer.set(key, value, ttl))
    );
  }
}

// Memory layer
class MemoryCache<T> implements CacheLayer<T> {
  private cache = new Map<string, { value: T; expires: number }>();

  async get(key: string): Promise<T | null> {
    const entry = this.cache.get(key);
    if (!entry) return null;
    if (Date.now() > entry.expires) {
      this.cache.delete(key);
      return null;
    }
    return entry.value;
  }

  async set(key: string, value: T, ttl = 60): Promise<void> {
    this.cache.set(key, {
      value,
      expires: Date.now() + ttl * 1000,
    });
  }
}

// Edge cache layer
class EdgeCache<T> implements CacheLayer<T> {
  private cache = caches.default;

  async get(key: string): Promise<T | null> {
    const response = await this.cache.match(new Request(`https://cache/${key}`));
    return response ? response.json() : null;
  }

  async set(key: string, value: T, ttl = 3600): Promise<void> {
    await this.cache.put(
      new Request(`https://cache/${key}`),
      new Response(JSON.stringify(value), {
        headers: { 'Cache-Control': `max-age=${ttl}` },
      })
    );
  }
}

// Usage
const cache = new MultiLayerCache<User>([
  new MemoryCache(),  // Fast, request-scoped
  new EdgeCache(),    // Medium, per-colo
  new KVCache(env.KV) // Slow, global
]);

Cache Invalidation

Tag-Based Invalidation

interface TaggedCacheEntry<T> {
  data: T;
  tags: string[];
}

class TaggedCache<T> {
  constructor(private kv: KVNamespace) {}

  async set(key: string, data: T, tags: string[], ttl = 3600): Promise<void> {
    // Store entry
    await this.kv.put(
      `entry:${key}`,
      JSON.stringify({ data, tags }),
      { expirationTtl: ttl }
    );

    // Update tag indexes
    for (const tag of tags) {
      const tagKeys = await this.kv.get<string[]>(`tag:${tag}`, 'json') || [];
      if (!tagKeys.includes(key)) {
        tagKeys.push(key);
        await this.kv.put(`tag:${tag}`, JSON.stringify(tagKeys));
      }
    }
  }

  async invalidateByTag(tag: string): Promise<void> {
    const tagKeys = await this.kv.get<string[]>(`tag:${tag}`, 'json') || [];

    await Promise.all(
      tagKeys.map(key => this.kv.delete(`entry:${key}`))
    );

    await this.kv.delete(`tag:${tag}`);
  }
}

// Usage
await taggedCache.set('user:123', userData, ['users', 'team:456']);

// Invalidate all users
await taggedCache.invalidateByTag('users');

Purge API

async function purgeCache(urls: string[], apiToken: string, zoneId: string): Promise<void> {
  const response = await fetch(
    `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiToken}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ files: urls }),
    }
  );

  if (!response.ok) {
    throw new Error(`Cache purge failed: ${response.statusText}`);
  }
}

Cache Headers

Setting Cache Headers

function setCacheHeaders(
  response: Response,
  options: {
    maxAge?: number;
    sMaxAge?: number;
    staleWhileRevalidate?: number;
    staleIfError?: number;
    private?: boolean;
    noStore?: boolean;
  }
): Response {
  const newResponse = new Response(response.body, response);
  const directives: string[] = [];

  if (options.noStore) {
    directives.push('no-store');
  } else {
    if (options.private) {
      directives.push('private');
    } else {
      directives.push('public');
    }

    if (options.maxAge !== undefined) {
      directives.push(`max-age=${options.maxAge}`);
    }

    if (options.sMaxAge !== undefined) {
      directives.push(`s-maxage=${options.sMaxAge}`);
    }

    if (options.staleWhileRevalidate !== undefined) {
      directives.push(`stale-while-revalidate=${options.staleWhileRevalidate}`);
    }

    if (options.staleIfError !== undefined) {
      directives.push(`stale-if-error=${options.staleIfError}`);
    }
  }

  newResponse.headers.set('Cache-Control', directives.join(', '));

  return newResponse;
}

// Usage
const response = setCacheHeaders(originalResponse, {
  maxAge: 60,           // Browser cache: 1 minute
  sMaxAge: 3600,        // CDN cache: 1 hour
  staleWhileRevalidate: 86400,  // Serve stale for 1 day while revalidating
  staleIfError: 86400,  // Serve stale for 1 day on origin error
});

Cold Start Optimization for Cloudflare Workers

Techniques for minimizing cold start latency and improving first-request performance.

Understanding Cold Starts

Cold starts occur when: 1. First request to a new colo (data center) 2. Worker hasn't been used recently 3. After deployment 4. Isolate recycling due to memory pressure

Cold Start Anatomy

Request → DNS → Edge → Isolate Creation → V8 Initialization → Module Evaluation → Handler Execution
                       └─────────────────── Cold Start Time ───────────────────┘

Typical cold start: 5-50ms depending on bundle size and initialization.

Measuring Cold Starts

Server-Timing Header

let isWarm = false;

export default {
  async fetch(request: Request): Promise<Response> {
    const start = performance.now();
    const wasCold = !isWarm;
    isWarm = true;

    const response = await handleRequest(request);

    // Add timing info
    const newResponse = new Response(response.body, response);
    const handlerTime = performance.now() - start;

    newResponse.headers.set(
      'Server-Timing',
      `handler;dur=${handlerTime.toFixed(2)}, cold;desc="${wasCold}"`
    );

    return newResponse;
  }
};

Cold Start Logging

interface StartupMetrics {
  isCold: boolean;
  startupTime?: number;
  moduleLoadTime?: number;
}

const moduleLoadStart = Date.now();

// Track module initialization
const moduleLoadTime = Date.now() - moduleLoadStart;
let isolateStartTime: number | undefined;
let isFirstRequest = true;

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const requestStart = Date.now();
    const metrics: StartupMetrics = { isCold: false };

    if (isFirstRequest) {
      isFirstRequest = false;
      isolateStartTime = requestStart;
      metrics.isCold = true;
      metrics.moduleLoadTime = moduleLoadTime;
    }

    const response = await handleRequest(request, env);

    if (metrics.isCold) {
      metrics.startupTime = Date.now() - requestStart;
      console.log('Cold start metrics:', metrics);
    }

    return response;
  }
};

Reducing Cold Start Time

Minimize Top-Level Code

// ❌ Bad: Heavy initialization at module load
import { parse } from 'yaml';
import { readFileSync } from 'fs';

const config = parse(readFileSync('./config.yaml', 'utf8'));
const cache = new Map(Object.entries(config.cache));
const validators = Object.keys(config.routes).map(createValidator);

// ✅ Good: Lazy initialization
let config: Config | undefined;
let cache: Map<string, unknown> | undefined;
let validators: Validator[] | undefined;

function getConfig(): Config {
  if (!config) {
    config = JSON.parse(CONFIG_JSON); // Use JSON instead of YAML
  }
  return config;
}

function getCache(): Map<string, unknown> {
  if (!cache) {
    cache = new Map();
  }
  return cache;
}

Defer Heavy Imports

// ❌ Bad: Import at top level
import { createCanvas, Image } from 'canvas';
import sharp from 'sharp';

// ✅ Good: Import when needed
let sharp: typeof import('sharp') | undefined;

async function processImage(input: ArrayBuffer): Promise<ArrayBuffer> {
  if (!sharp) {
    sharp = await import('sharp');
  }

  return sharp.default(input)
    .resize(800, 600)
    .toBuffer();
}

Singleton Pattern for Expensive Objects

// Lazy singleton pattern
class DatabaseConnection {
  private static instance: DatabaseConnection | undefined;

  private constructor(private db: D1Database) {}

  static getInstance(db: D1Database): DatabaseConnection {
    if (!DatabaseConnection.instance) {
      DatabaseConnection.instance = new DatabaseConnection(db);
    }
    return DatabaseConnection.instance;
  }

  async query(sql: string, params: unknown[]): Promise<unknown[]> {
    return this.db.prepare(sql).bind(...params).all();
  }
}

Avoid Synchronous Operations

// ❌ Bad: Sync operations block startup
const data = JSON.parse(largeJsonString); // Blocks
const sorted = data.sort((a, b) => a.name.localeCompare(b.name)); // Blocks

// ✅ Good: Async initialization
let sortedData: Data[] | undefined;

async function getSortedData(): Promise<Data[]> {
  if (!sortedData) {
    // Parse and sort on first request, not module load
    const data = JSON.parse(largeJsonString);
    sortedData = data.sort((a, b) => a.name.localeCompare(b.name));
  }
  return sortedData;
}

Bundle Size Impact

Size vs Cold Start Time

Minimize Bundle

// esbuild.config.ts
import * as esbuild from 'esbuild';

await esbuild.build({
  entryPoints: ['src/index.ts'],
  bundle: true,
  minify: true,
  treeShaking: true,
  format: 'esm',
  target: 'es2022',
  drop: ['console', 'debugger'],
  mangleProps: /^_/, // Mangle private properties
  outfile: 'dist/index.js',
});

Warming Strategies

Cron-Based Warming

// Keep worker warm with scheduled requests
export default {
  async fetch(request: Request): Promise<Response> {
    return handleRequest(request);
  },

  async scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext): Promise<void> {
    // Called by cron trigger every 5 minutes
    // Just accessing the worker keeps it warm

    // Optionally pre-warm caches
    ctx.waitUntil(prewarmCaches(env));
  },
};

// wrangler.jsonc
// "triggers": {
//   "crons": ["*/5 * * * *"]  // Every 5 minutes
// }

Service Binding Warming

// From main worker, periodically call dependent workers
async function warmServices(env: Env): Promise<void> {
  await Promise.all([
    env.AUTH_SERVICE.fetch(new Request('http://internal/health')),
    env.DATA_SERVICE.fetch(new Request('http://internal/health')),
    env.CACHE_SERVICE.fetch(new Request('http://internal/health')),
  ]);
}

Multi-Colo Warming

// Warm worker in multiple colos
async function warmGlobally(workerUrl: string, locations: string[]): Promise<void> {
  // Use Cloudflare Durable Objects or external service
  // to make requests from different regions

  for (const location of locations) {
    // Request through specific colo
    await fetch(workerUrl, {
      headers: {
        'CF-Preferred-Colo': location, // Not a real header - illustration only
      },
    });
  }
}

Isolate Reuse

Global State Considerations

// Global state persists across requests in the same isolate
let requestCount = 0;
let lastRequestTime = 0;

export default {
  async fetch(request: Request): Promise<Response> {
    requestCount++;
    lastRequestTime = Date.now();

    // ⚠️ Be careful with global state
    // - Don't store request-specific data
    // - Don't store sensitive information
    // - Do use for caching and connection pooling

    return handleRequest(request);
  }
};

Connection Pooling

// Reuse connections across requests
let dbConnection: DatabaseConnection | undefined;

function getConnection(env: Env): DatabaseConnection {
  if (!dbConnection) {
    dbConnection = new DatabaseConnection(env.DB);
  }
  return dbConnection;
}

// Will be reused for subsequent requests in same isolate

Preloading

Preload Common Data

// Preload data likely to be needed
let commonData: CommonData | undefined;

async function preload(env: Env): Promise<void> {
  if (!commonData) {
    // Load common data once per isolate
    commonData = {
      config: await env.KV.get('config', 'json'),
      translations: await env.KV.get('translations', 'json'),
      routes: await env.KV.get('routes', 'json'),
    };
  }
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    // Preload in background on first request
    ctx.waitUntil(preload(env));

    return handleRequest(request, env);
  }
};

Speculative Preloading

// Predict and preload based on request patterns
const prefetchMap = new Map<string, string[]>([
  ['/products', ['/api/categories', '/api/featured']],
  ['/checkout', ['/api/payment-methods', '/api/shipping']],
]);

async function speculativePrefetch(
  path: string,
  env: Env
): Promise<void> {
  const toPrefetch = prefetchMap.get(path);
  if (!toPrefetch) return;

  await Promise.all(
    toPrefetch.map(async (url) => {
      // Prefetch and cache
      const response = await fetch(url);
      await caches.default.put(new Request(url), response);
    })
  );
}

Monitoring Cold Starts

Analytics Engine Tracking

interface ColdStartMetric {
  timestamp: number;
  isCold: boolean;
  startupMs: number;
  bundleSize: number;
  colo: string;
}

function trackColdStart(
  analytics: AnalyticsEngineDataset,
  metrics: ColdStartMetric
): void {
  analytics.writeDataPoint({
    indexes: [metrics.colo],
    blobs: [metrics.isCold ? 'cold' : 'warm'],
    doubles: [metrics.startupMs, metrics.bundleSize],
  });
}

// Query cold start metrics
// SELECT
//   blob1 as start_type,
//   AVG(double1) as avg_startup_ms,
//   COUNT(*) as count
// FROM worker_cold_starts
// WHERE timestamp > now() - interval '1' hour
// GROUP BY start_type

CPU Optimization for Cloudflare Workers

Techniques for staying within CPU time limits and maximizing throughput.

Understanding CPU Limits

CPU time is actual execution time, not wall-clock time. Waiting for I/O doesn't count.

Profiling CPU Usage

Basic Timing

class CPUProfiler {
  private marks: Map<string, number> = new Map();
  private measures: Map<string, number[]> = new Map();

  mark(name: string): void {
    this.marks.set(name, performance.now());
  }

  measure(name: string, startMark: string): number {
    const start = this.marks.get(startMark);
    if (!start) throw new Error(`Mark ${startMark} not found`);

    const duration = performance.now() - start;

    const existing = this.measures.get(name) || [];
    existing.push(duration);
    this.measures.set(name, existing);

    return duration;
  }

  getSummary(): Record<string, { count: number; total: number; avg: number; max: number }> {
    const summary: Record<string, { count: number; total: number; avg: number; max: number }> = {};

    for (const [name, times] of this.measures) {
      summary[name] = {
        count: times.length,
        total: times.reduce((a, b) => a + b, 0),
        avg: times.reduce((a, b) => a + b, 0) / times.length,
        max: Math.max(...times),
      };
    }

    return summary;
  }

  reset(): void {
    this.marks.clear();
    this.measures.clear();
  }
}

// Usage
const profiler = new CPUProfiler();

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    profiler.mark('start');

    profiler.mark('parse-start');
    const data = await request.json();
    profiler.measure('parse', 'parse-start');

    profiler.mark('process-start');
    const result = processData(data);
    profiler.measure('process', 'process-start');

    profiler.measure('total', 'start');

    console.log('CPU Profile:', profiler.getSummary());

    return Response.json(result);
  }
};

Async Profiling with Context

interface ProfileContext {
  requestId: string;
  timings: Record<string, number>;
}

async function withProfiling<T>(
  ctx: ProfileContext,
  name: string,
  fn: () => Promise<T>
): Promise<T> {
  const start = performance.now();
  try {
    return await fn();
  } finally {
    ctx.timings[name] = performance.now() - start;
  }
}

// Usage
const ctx: ProfileContext = {
  requestId: crypto.randomUUID(),
  timings: {},
};

const user = await withProfiling(ctx, 'fetchUser', () =>
  db.prepare('SELECT * FROM users WHERE id = ?').bind(userId).first()
);

const orders = await withProfiling(ctx, 'fetchOrders', () =>
  db.prepare('SELECT * FROM orders WHERE user_id = ?').bind(userId).all()
);

console.log(`[${ctx.requestId}] Timings:`, ctx.timings);

CPU-Intensive Operation Patterns

Batch Processing

// ❌ Bad: Process one at a time
for (const item of items) {
  await processItem(item);
}

// ✅ Good: Process in parallel batches
async function processBatch<T, R>(
  items: T[],
  processor: (item: T) => Promise<R>,
  batchSize = 10
): Promise<R[]> {
  const results: R[] = [];

  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const batchResults = await Promise.all(batch.map(processor));
    results.push(...batchResults);
  }

  return results;
}

Chunked Processing with Yielding

// For very long arrays, yield to event loop
async function processWithYield<T, R>(
  items: T[],
  processor: (item: T) => R,
  chunkSize = 100
): Promise<R[]> {
  const results: R[] = [];

  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    results.push(...chunk.map(processor));

    // Yield to event loop every chunk
    await new Promise(resolve => setTimeout(resolve, 0));
  }

  return results;
}

Memoization

// In-request memoization
function memoize<T extends (...args: unknown[]) => unknown>(
  fn: T,
  keyFn?: (...args: Parameters<T>) => string
): T {
  const cache = new Map<string, ReturnType<T>>();

  return ((...args: Parameters<T>) => {
    const key = keyFn ? keyFn(...args) : JSON.stringify(args);

    if (cache.has(key)) {
      return cache.get(key)!;
    }

    const result = fn(...args);
    cache.set(key, result as ReturnType<T>);
    return result;
  }) as T;
}

// Usage
const expensiveCalculation = memoize((x: number, y: number) => {
  // Expensive computation
  return x ** y;
});

Optimizing Common Operations

String Operations

// ❌ Bad: String concatenation in loop
let result = '';
for (const item of items) {
  result += item.toString() + ',';
}

// ✅ Good: Use array join
const result = items.map(item => item.toString()).join(',');

// ✅ Even better for large strings: Use TextEncoder
const encoder = new TextEncoder();
const parts: Uint8Array[] = items.map(item =>
  encoder.encode(item.toString())
);

JSON Operations

// ❌ Bad: Parse then stringify
const obj = JSON.parse(jsonString);
obj.newField = 'value';
const result = JSON.stringify(obj);

// ✅ Good: For simple additions, use string manipulation
const result = jsonString.slice(0, -1) + ',"newField":"value"}';

// ✅ Best: Use streaming for large JSON
import { JSONParser } from '@streamparser/json';

async function processLargeJSON(stream: ReadableStream): Promise<void> {
  const parser = new JSONParser({ paths: ['$.items.*'] });

  parser.onValue = (value, key, parent, stack) => {
    // Process each item as it's parsed
    processItem(value);
  };

  const reader = stream.getReader();
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    parser.write(value);
  }
}

Regular Expressions

// ❌ Bad: Create regex in hot path
function findMatches(text: string, pattern: string): string[] {
  const regex = new RegExp(pattern, 'g');
  return text.match(regex) || [];
}

// ✅ Good: Pre-compile regex
const EMAIL_REGEX = /[\w.-]+@[\w.-]+\.\w+/g;

function findEmails(text: string): string[] {
  return text.match(EMAIL_REGEX) || [];
}

// ✅ Even better: Use simpler string methods when possible
function containsKeyword(text: string, keyword: string): boolean {
  // indexOf is faster than regex for simple checks
  return text.toLowerCase().indexOf(keyword.toLowerCase()) !== -1;
}

Object Operations

// ❌ Bad: Spread operator for large objects
const merged = { ...largeObj1, ...largeObj2 };

// ✅ Good: Object.assign for mutation
const result = Object.assign({}, largeObj1, largeObj2);

// ✅ Even better: Mutate if original not needed
Object.assign(largeObj1, largeObj2);

// ❌ Bad: Object.keys().forEach for iteration
Object.keys(obj).forEach(key => {
  process(obj[key]);
});

// ✅ Good: for...in with hasOwnProperty
for (const key in obj) {
  if (Object.hasOwn(obj, key)) {
    process(obj[key]);
  }
}

Avoiding CPU Spikes

Spread Operations Out

// ❌ Bad: All at once
const results = await Promise.all(
  thousandsOfItems.map(async item => heavyProcessing(item))
);

// ✅ Good: Rate-limited processing
async function rateLimitedProcess<T, R>(
  items: T[],
  processor: (item: T) => Promise<R>,
  concurrency = 5
): Promise<R[]> {
  const results: R[] = [];
  const executing: Promise<void>[] = [];

  for (const item of items) {
    const p = processor(item).then(result => {
      results.push(result);
    });
    executing.push(p);

    if (executing.length >= concurrency) {
      await Promise.race(executing);
      executing.splice(
        executing.findIndex(e => e === p),
        1
      );
    }
  }

  await Promise.all(executing);
  return results;
}

Early Returns

// ❌ Bad: Process everything then filter
const processed = items.map(item => expensiveTransform(item));
const filtered = processed.filter(item => item.isValid);

// ✅ Good: Filter first, then process
const valid = items.filter(item => quickValidation(item));
const processed = valid.map(item => expensiveTransform(item));

// ✅ Even better: Short-circuit when possible
function processUntilLimit(items: Item[], limit: number): Result[] {
  const results: Result[] = [];

  for (const item of items) {
    if (results.length >= limit) break;

    const result = process(item);
    if (result.isValid) {
      results.push(result);
    }
  }

  return results;
}

CPU Time Monitoring

Add Timing Headers

function addTimingHeaders(response: Response, timings: Record<string, number>): Response {
  const newResponse = new Response(response.body, response);

  // Server-Timing header for DevTools
  const serverTiming = Object.entries(timings)
    .map(([name, duration]) => `${name};dur=${duration}`)
    .join(', ');

  newResponse.headers.set('Server-Timing', serverTiming);

  return newResponse;
}

Logging Slow Requests

const SLOW_THRESHOLD_MS = 20;

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const start = performance.now();

    try {
      return await handleRequest(request, env);
    } finally {
      const duration = performance.now() - start;

      if (duration > SLOW_THRESHOLD_MS) {
        console.warn('Slow request:', {
          url: request.url,
          method: request.method,
          duration: `${duration.toFixed(2)}ms`,
        });
      }
    }
  }
};

Memory Optimization for Cloudflare Workers

Techniques for efficient memory usage within Worker limits.

Memory Limits

The 128 MB limit is per-isolate, shared across all requests in that isolate.

Memory Profiling

Estimate Object Size

function estimateSize(obj: unknown, seen = new WeakSet()): number {
  if (obj === null || obj === undefined) return 0;

  const type = typeof obj;

  if (type === 'boolean') return 4;
  if (type === 'number') return 8;
  if (type === 'string') return (obj as string).length * 2;

  if (type !== 'object') return 0;

  // Avoid circular references
  if (seen.has(obj as object)) return 0;
  seen.add(obj as object);

  if (obj instanceof ArrayBuffer) {
    return obj.byteLength;
  }

  if (ArrayBuffer.isView(obj)) {
    return obj.byteLength;
  }

  if (Array.isArray(obj)) {
    return obj.reduce((sum, item) => sum + estimateSize(item, seen), 0);
  }

  // Regular object
  return Object.entries(obj).reduce(
    (sum, [key, value]) => sum + key.length * 2 + estimateSize(value, seen),
    0
  );
}

// Usage
const data = await response.json();
const sizeKB = estimateSize(data) / 1024;
console.log(`Response size: ${sizeKB.toFixed(2)} KB`);

if (sizeKB > 1000) {
  console.warn('Large response detected, consider streaming');
}

Track Memory Usage

interface MemoryTracker {
  allocations: Map<string, number>;
  track(label: string, size: number): void;
  release(label: string): void;
  getSummary(): { total: number; breakdown: Record<string, number> };
}

function createMemoryTracker(): MemoryTracker {
  const allocations = new Map<string, number>();

  return {
    allocations,

    track(label: string, size: number): void {
      const current = allocations.get(label) || 0;
      allocations.set(label, current + size);
    },

    release(label: string): void {
      allocations.delete(label);
    },

    getSummary(): { total: number; breakdown: Record<string, number> } {
      const breakdown: Record<string, number> = {};
      let total = 0;

      for (const [label, size] of allocations) {
        breakdown[label] = size;
        total += size;
      }

      return { total, breakdown };
    },
  };
}

Streaming Large Data

Stream Response Bodies

// ❌ Bad: Buffer entire response
async function transformResponse(response: Response): Promise<Response> {
  const text = await response.text(); // Buffers all data
  const transformed = transform(text);
  return new Response(transformed);
}

// ✅ Good: Stream transformation
function streamTransform(response: Response): Response {
  const reader = response.body?.getReader();
  if (!reader) return response;

  const stream = new ReadableStream({
    async pull(controller) {
      const { done, value } = await reader.read();

      if (done) {
        controller.close();
        return;
      }

      // Transform chunk
      const transformed = processChunk(value);
      controller.enqueue(transformed);
    },

    cancel() {
      reader.cancel();
    },
  });

  return new Response(stream, {
    headers: response.headers,
  });
}

Stream JSON Processing

// For large JSON arrays, process items one at a time
async function* streamJSONArray<T>(
  response: Response
): AsyncGenerator<T, void, unknown> {
  const reader = response.body!.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
  let inArray = false;
  let depth = 0;
  let itemStart = -1;

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });

    for (let i = 0; i < buffer.length; i++) {
      const char = buffer[i];

      if (char === '[' && !inArray) {
        inArray = true;
        itemStart = i + 1;
      } else if (char === '{') {
        if (depth === 0) itemStart = i;
        depth++;
      } else if (char === '}') {
        depth--;
        if (depth === 0 && inArray) {
          const item = buffer.slice(itemStart, i + 1);
          yield JSON.parse(item) as T;
          itemStart = i + 2; // Skip comma
        }
      }
    }

    // Keep only unprocessed data
    if (itemStart > 0) {
      buffer = buffer.slice(itemStart);
      itemStart = 0;
    }
  }
}

// Usage
for await (const item of streamJSONArray<User>(response)) {
  await processUser(item);
  // Each item is processed and can be GC'd
}

Avoiding Memory Leaks

Clean Up Event Listeners

// ❌ Bad: Listeners accumulate
class DataProcessor {
  private emitter = new EventTarget();

  process(data: unknown): void {
    this.emitter.addEventListener('complete', () => {
      // This listener stays forever
      console.log('Complete');
    });
  }
}

// ✅ Good: Use AbortController for cleanup
class DataProcessor {
  process(data: unknown, signal?: AbortSignal): void {
    const controller = new AbortController();

    this.emitter.addEventListener(
      'complete',
      () => console.log('Complete'),
      { signal: controller.signal }
    );

    // Auto-cleanup when done
    signal?.addEventListener('abort', () => controller.abort());
  }
}

Clear Caches

// Request-scoped cache with size limit
class BoundedCache<K, V> {
  private cache = new Map<K, V>();
  private maxSize: number;

  constructor(maxSize = 100) {
    this.maxSize = maxSize;
  }

  get(key: K): V | undefined {
    return this.cache.get(key);
  }

  set(key: K, value: V): void {
    // Evict oldest if at capacity
    if (this.cache.size >= this.maxSize) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }

    this.cache.set(key, value);
  }

  clear(): void {
    this.cache.clear();
  }
}

Avoid Closures Capturing Large Data

// ❌ Bad: Closure captures largeData
function createHandler(largeData: unknown[]) {
  return async (request: Request) => {
    // largeData stays in memory
    return Response.json(largeData);
  };
}

// ✅ Good: Access data through reference
const dataStore = new Map<string, unknown[]>();

function createHandler(dataKey: string) {
  return async (request: Request) => {
    const data = dataStore.get(dataKey);
    return Response.json(data);
  };
}

Efficient Data Structures

Use TypedArrays for Binary Data

// ❌ Bad: Regular array for bytes
const bytes: number[] = [];
for (let i = 0; i < 10000; i++) {
  bytes.push(i % 256);
}

// ✅ Good: Uint8Array
const bytes = new Uint8Array(10000);
for (let i = 0; i < 10000; i++) {
  bytes[i] = i % 256;
}

Use Map/Set Over Objects for Dynamic Keys

// For frequent additions/deletions
// ❌ Less efficient with many keys
const cache: Record<string, unknown> = {};
cache[key] = value;
delete cache[key];

// ✅ More efficient for dynamic keys
const cache = new Map<string, unknown>();
cache.set(key, value);
cache.delete(key);

Reuse Buffers

// ❌ Bad: Create new buffer each time
function processChunks(chunks: Uint8Array[]): Uint8Array {
  const results: Uint8Array[] = [];

  for (const chunk of chunks) {
    const result = new Uint8Array(chunk.length);
    // Process...
    results.push(result);
  }

  return concatenate(results);
}

// ✅ Good: Reuse single buffer
function processChunks(chunks: Uint8Array[], bufferSize = 65536): Uint8Array {
  const buffer = new Uint8Array(bufferSize);
  const results: Uint8Array[] = [];
  let offset = 0;

  for (const chunk of chunks) {
    // Write to buffer
    buffer.set(chunk, offset);
    offset += chunk.length;

    // Flush when full
    if (offset >= bufferSize - 1024) {
      results.push(buffer.slice(0, offset));
      offset = 0;
    }
  }

  if (offset > 0) {
    results.push(buffer.slice(0, offset));
  }

  return concatenate(results);
}

Garbage Collection Hints

Null Out References

async function processLargeData(data: LargeObject): Promise<Result> {
  const intermediate = transform(data);

  // Release original data for GC
  data = null as unknown as LargeObject;

  const result = finalize(intermediate);

  // Release intermediate
  intermediate = null as unknown as typeof intermediate;

  return result;
}

Process in Chunks with GC Opportunities

async function processInChunks<T, R>(
  items: T[],
  processor: (batch: T[]) => Promise<R[]>,
  chunkSize = 100
): Promise<R[]> {
  const results: R[] = [];

  for (let i = 0; i < items.length; i += chunkSize) {
    const chunk = items.slice(i, i + chunkSize);
    const chunkResults = await processor(chunk);
    results.push(...chunkResults);

    // Yield to event loop, allowing GC
    await new Promise(resolve => setTimeout(resolve, 0));
  }

  return results;
}

Memory-Efficient Patterns

Pagination for Large Results

interface PaginatedQuery {
  getData(offset: number, limit: number): Promise<unknown[]>;
}

async function* paginate<T>(
  query: PaginatedQuery,
  pageSize = 100
): AsyncGenerator<T[], void, unknown> {
  let offset = 0;

  while (true) {
    const page = await query.getData(offset, pageSize) as T[];

    if (page.length === 0) break;

    yield page;

    if (page.length < pageSize) break;

    offset += pageSize;
  }
}

// Usage
for await (const page of paginate<User>(userQuery)) {
  await processUsers(page);
  // Previous page can be GC'd
}

Flyweight Pattern for Repeated Objects

// Share common data between many objects
class UserFactory {
  private roleCache = new Map<string, Role>();

  createUser(data: UserData): User {
    // Reuse role object instead of creating new one
    let role = this.roleCache.get(data.roleId);
    if (!role) {
      role = new Role(data.roleId);
      this.roleCache.set(data.roleId, role);
    }

    return new User(data.id, data.name, role);
  }
}