createWorld

import { createWorld } from 'workflow/runtime';

const world = createWorld();

function createWorld(): World

WORKFLOW_TARGET_WORLD=./my-custom-world.js

interface World {
  // Event sourcing
  events: {
    create(runId: string, event: Event): Promise<{ event: Event; run: WorkflowRun }>;
  };

  // Run management
  runs: {
    get(runId: string): Promise<WorkflowRun>;
  };

  // Queue operations
  queue(queueName: string, payload: unknown, options?: QueueOptions): Promise<void>;
  createQueueHandler(prefix: string, handler: Function): Function;

  // Deployment info
  getDeploymentId(): Promise<string>;

  // Encryption (optional)
  getEncryptionKeyForRun?(run: WorkflowRun | string, context?: any): Promise<Uint8Array | undefined>;
}

import { getWorld } from 'workflow/runtime';

const world = getWorld();

import { setWorld } from 'workflow/runtime';

setWorld(customWorld);

import { getWorldHandlers } from 'workflow/runtime';

const handlers = getWorldHandlers();
const queueHandler = handlers.createQueueHandler('__prefix_', async (msg) => {
  // Handle message
});

import { getWorld } from 'workflow/runtime';

// Get the current world (auto-created if needed)
const world = getWorld();

// Access run information
const run = await world.runs.get('wrun_123');
console.log('Status:', run.status);

import { setWorld } from 'workflow/runtime';
import { createLocalWorld } from '@workflow/world-local';

// Use local world for testing
const testWorld = createLocalWorld({
  dataDir: './test-data',
});

setWorld(testWorld);

// Run tests...

// Clean up
setWorld(undefined);

# .env.production
WORKFLOW_VERCEL_AUTH_TOKEN=your-token
WORKFLOW_VERCEL_PROJECT=prj_xxx
WORKFLOW_VERCEL_PROJECT_NAME=my-app
WORKFLOW_VERCEL_ENV=production

// Automatically uses Vercel world when deployed
import { getWorld } from 'workflow/runtime';

const world = getWorld(); // Returns Vercel world

// custom-world.ts
import type { World } from '@workflow/world';

export function createWorld(): World {
  return {
    events: {
      async create(runId, event) {
        // Custom event storage
        const stored = await myDatabase.insertEvent(runId, event);
        const run = await this.runs.get(runId);
        return { event: stored, run };
      },
    },
    runs: {
      async get(runId) {
        return await myDatabase.getRun(runId);
      },
    },
    async queue(queueName, payload) {
      await myQueue.enqueue(queueName, payload);
    },
    createQueueHandler(prefix, handler) {
      return myQueue.createHandler(prefix, handler);
    },
    async getDeploymentId() {
      return process.env.DEPLOYMENT_ID || 'local';
    },
  };
}

# Use custom world
WORKFLOW_TARGET_WORLD=./custom-world.js

interface WorkflowRun {
  runId: string;
  workflowName: string;
  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
  createdAt: Date;
  startedAt?: Date;
  completedAt?: Date;
  output?: any;
  error?: {
    message: string;
    stack?: string;
  };
}

type Event = 
  | { eventType: 'run_created'; eventData: { workflowName: string; input: any; ... } }
  | { eventType: 'run_started'; specVersion: number }
  | { eventType: 'run_completed'; eventData: { output: any } }
  | { eventType: 'run_failed'; eventData: { error: { message: string; stack?: string } } }
  | { eventType: 'run_cancelled'; specVersion: number }
  | { eventType: 'wait_created'; correlationId: string; eventData: { resumeAt: Date } }
  | { eventType: 'wait_completed'; correlationId: string }
  // ... and more event types