@goatlab/tasks-adapter-hatchet 0.3.4 → 0.4.0

package/dist/HatchetConnector.d.ts

@@ -1,18 +1,128 @@
-import type { ShouldQueue, TaskConnector, TaskStatus } from '@goatlab/tasks-core';
+import type { ShouldQueue, TaskConnector, TaskStatus, TenantCredentials } from '@goatlab/tasks-core';
 import { Hatchet } from '@hatchet-dev/typescript-sdk';
+/**
+ * HatchetConnector - TaskConnector implementation for Hatchet.
+ *
+ * ## Implementation Notes
+ *
+ * ### Why we use `admin.runWorkflow()` instead of `task.runNoWait()`
+ *
+ * Both methods are fire-and-forget (they only wait for the run ID, not task completion).
+ * However, `task.runNoWait()` internally uses a global `parentRunContextManager` to track
+ * parent/child workflow relationships:
+ *
+ * ```js
+ * // Inside task.runNoWait() - declaration.js:46-47
+ * const parentRunContext = parentRunContextManager.getContext();
+ * parentRunContextManager.incrementChildIndex(...);
+ * ```
+ *
+ * This global state causes issues when queuing many tasks rapidly in parallel - concurrent
+ * calls interfere with each other through this shared state, potentially causing duplicate
+ * run IDs or other race conditions.
+ *
+ * By calling `admin.runWorkflow()` directly, we bypass:
+ * - The `parentRunContextManager` global state
+ * - The `childIndex` tracking
+ * - The `childKey` / `sticky` handling
+ *
+ * These features are designed for spawning child workflows from within a parent task,
+ * not for high-volume top-level task queuing.
+ *
+ * ### Eventual Consistency between gRPC and REST API
+ *
+ * Hatchet uses gRPC for `queue()` (triggerWorkflow) and REST API for `getStatus()` (runs.get).
+ * There can be a brief delay before a newly created run is visible via REST API.
+ * We handle this with retry logic in `getStatus()`.
+ *
+ * @see https://docs.hatchet.run/home/run-no-wait
+ * @see https://docs.hatchet.run/home/v1-sdk-improvements
+ */
+/**
+ * Configuration for HatchetConnector
+ */
+export interface HatchetConnectorConfig {
+    /**
+     * Hatchet API token for authentication.
+     */
+    token: string;
+    /**
+     * Hatchet gRPC host and port.
+     * Default: 'localhost:7077'
+     */
+    hostAndPort?: string;
+    /**
+     * Hatchet REST API URL.
+     * Default: 'http://localhost:8888'
+     */
+    apiUrl?: string;
+    /**
+     * Log level for Hatchet client.
+     * Default: 'INFO'
+     */
+    logLevel?: 'INFO' | 'OFF' | 'DEBUG' | 'WARN' | 'ERROR';
+    /**
+     * Hatchet's internal tenant ID (requires separate token per tenant).
+     * This is different from our multi-tenant isolation - use `tenantId` instead.
+     */
+    hatchetTenantId?: string;
+    /**
+     * Tenant ID for multi-tenant isolation using Hatchet namespaces.
+     * When set, this is used as the Hatchet namespace to isolate:
+     * - Workflows only trigger for this namespace
+     * - Events remain isolated to this namespace
+     * - Workers only process jobs from this namespace
+     *
+     * This allows multiple tenants to share the same Hatchet instance
+     * and token while maintaining isolation.
+     */
+    tenantId?: string;
+}
 export declare class HatchetConnector implements TaskConnector<object> {
     private readonly token;
     private readonly hostAndPort;
     private readonly apiUrl;
     private readonly logLevel;
-    private readonly tenantId;
-    constructor({ token, hostAndPort, apiUrl, logLevel, tenantId }: {
-        token: string;
-        hostAndPort?: string;
-        apiUrl?: string;
-        logLevel: 'INFO' | 'OFF' | 'DEBUG' | 'WARN' | 'ERROR';
-        tenantId?: string;
-    });
+    private readonly hatchetTenantId;
+    private readonly _tenantId?;
+    private readonly config;
+    private registeredWorkflows;
+    /**
+     * The tenant ID this connector is scoped to.
+     * Uses Hatchet namespaces for isolation within the same Hatchet instance.
+     */
+    get tenantId(): string | undefined;
+    /**
+     * The Hatchet namespace used for isolation.
+     * This is the same as tenantId when set.
+     */
+    get namespace(): string;
+    constructor(config: HatchetConnectorConfig);
+    /**
+     * Creates a new HatchetConnector instance scoped to a specific tenant.
+     * Uses Hatchet namespaces for isolation within the same Hatchet instance.
+     *
+     * @param tenantId - The tenant identifier for isolation (used as Hatchet namespace)
+     * @param _credentials - Not used for Hatchet (namespaces share the same token)
+     * @returns A new HatchetConnector instance scoped to the tenant
+     *
+     * @example
+     * ```typescript
+     * const baseConnector = new HatchetConnector({ token: 'my-token' })
+     *
+     * // Create tenant-scoped connector
+     * const tenantConnector = baseConnector.forTenant('acme-corp')
+     * // Namespace: acme-corp (workflows isolated to this namespace)
+     * ```
+     */
+    forTenant(tenantId: string, _credentials?: TenantCredentials): HatchetConnector;
+    /**
+     * Gets or creates a memoized Hatchet client.
+     *
+     * IMPORTANT: Due to memoization, each unique combination of config creates
+     * a separate client. This means tenant-scoped connectors get their own client
+     * with the correct namespace.
+     */
     getHatchetClient(): Hatchet;
     getHatchetTask(task: ShouldQueue): import("@hatchet-dev/typescript-sdk").TaskWorkflowDeclaration<import("@hatchet-dev/typescript-sdk").JsonObject, any>;
     startWorker({ workerName, tasks, slots }: {
@@ -21,18 +131,30 @@ export declare class HatchetConnector implements TaskConnector<object> {
         slots?: number;
     }): Promise<import("@hatchet-dev/typescript-sdk").Worker>;
     /**
-     * Gets the status of a task by its name.
-     * Implements the TaskConnector interface.
-     * @param name - Name of the task.
+     * Gets the status of a task by its Hatchet run ID.
+     *
+     * Uses `runs.get()` which calls the REST API endpoint `/api/v1/stable/workflow-runs/{id}`.
+     * Includes retry logic (3 attempts with exponential backoff) to handle eventual
+     * consistency between gRPC (used by queue) and REST API (used here).
+     *
+     * The payload is double-nested in Hatchet's response: `run.input.input` contains
+     * the actual payload we passed to `queue()`.
+     *
+     * @param id - The Hatchet workflow run ID returned by `queue()`.
+     * @returns Full task status including payload, status, and metadata.
+     * @throws Error if the run cannot be found after all retry attempts.
      */
     getStatus(id: string): Promise<TaskStatus>;
     /**
-     * Queues a task to be run in the background.
-     * Implements the TaskConnector interface.
-     * @param params
-     * @param params.taskName - Name of the task.
-     * @param params.postUrl - URL to post the task to.
-     * @param params.taskBody - Body of the task.
+     * Queues a task to be run in the background (fire-and-forget).
+     *
+     * Uses `admin.runWorkflow()` directly instead of `task.runNoWait()` to avoid
+     * the global `parentRunContextManager` state that causes race conditions
+     * when queuing tasks rapidly. See class documentation for details.
+     *
+     * @param params.taskName - Name of the task (must match a registered workflow).
+     * @param params.taskBody - The payload to pass to the task handler.
+     * @returns Task status with unique run ID. Does NOT wait for task completion.
      */
     queue(params: any): Promise<Omit<TaskStatus, 'payload'>>;
 }

package/dist/HatchetConnector.js

@@ -8,29 +8,81 @@ const typescript_sdk_1 = require("@hatchet-dev/typescript-sdk");
 const DEFAULT_HOST_PORT = 'localhost:7077';
 const DEFAULT_API_URL = 'http://localhost:8888';
 const DEFAULT_LOG_LEVEL = 'INFO';
-const DEFAULT_TENANT_ID = '707d0855-80ab-4e1f-a156-f1c4546cbf52';
+const DEFAULT_HATCHET_TENANT_ID = '707d0855-80ab-4e1f-a156-f1c4546cbf52';
 class HatchetConnector {
     token;
     hostAndPort;
     apiUrl;
     logLevel;
-    tenantId;
-    constructor({ token, hostAndPort, apiUrl, logLevel, tenantId }) {
-        this.token = token || '';
-        this.hostAndPort = hostAndPort || DEFAULT_HOST_PORT;
-        this.apiUrl = apiUrl || DEFAULT_API_URL;
-        this.logLevel = logLevel || DEFAULT_LOG_LEVEL;
-        this.tenantId = tenantId || '';
+    hatchetTenantId;
+    _tenantId;
+    config;
+    // Store registered workflows by taskName for reuse in queue()
+    registeredWorkflows = new Map();
+    /**
+     * The tenant ID this connector is scoped to.
+     * Uses Hatchet namespaces for isolation within the same Hatchet instance.
+     */
+    get tenantId() {
+        return this._tenantId;
+    }
+    /**
+     * The Hatchet namespace used for isolation.
+     * This is the same as tenantId when set.
+     */
+    get namespace() {
+        return this._tenantId || '';
+    }
+    constructor(config) {
+        this.config = config;
+        this.token = config.token || '';
+        this.hostAndPort = config.hostAndPort || DEFAULT_HOST_PORT;
+        this.apiUrl = config.apiUrl || DEFAULT_API_URL;
+        this.logLevel = config.logLevel || DEFAULT_LOG_LEVEL;
+        this.hatchetTenantId = config.hatchetTenantId || '';
+        this._tenantId = config.tenantId;
+    }
+    /**
+     * Creates a new HatchetConnector instance scoped to a specific tenant.
+     * Uses Hatchet namespaces for isolation within the same Hatchet instance.
+     *
+     * @param tenantId - The tenant identifier for isolation (used as Hatchet namespace)
+     * @param _credentials - Not used for Hatchet (namespaces share the same token)
+     * @returns A new HatchetConnector instance scoped to the tenant
+     *
+     * @example
+     * ```typescript
+     * const baseConnector = new HatchetConnector({ token: 'my-token' })
+     *
+     * // Create tenant-scoped connector
+     * const tenantConnector = baseConnector.forTenant('acme-corp')
+     * // Namespace: acme-corp (workflows isolated to this namespace)
+     * ```
+     */
+    forTenant(tenantId, _credentials) {
+        return new HatchetConnector({
+            ...this.config,
+            tenantId
+        });
     }
+    /**
+     * Gets or creates a memoized Hatchet client.
+     *
+     * IMPORTANT: Due to memoization, each unique combination of config creates
+     * a separate client. This means tenant-scoped connectors get their own client
+     * with the correct namespace.
+     */
     getHatchetClient() {
         const hatchet = typescript_sdk_1.Hatchet.init({
             token: this.token,
             host_port: this.hostAndPort,
             api_url: this.apiUrl,
             log_level: this.logLevel,
-            // This is the default tenantId for local development
-            tenant_id: this.tenantId || DEFAULT_TENANT_ID,
-            namespace: '',
+            // Hatchet's internal tenant ID (requires separate token)
+            tenant_id: this.hatchetTenantId || DEFAULT_HATCHET_TENANT_ID,
+            // Use tenantId as namespace for multi-tenant isolation
+            // This prefixes workflows and isolates events/workers
+            namespace: this._tenantId || '',
             tls_config: {
                 tls_strategy: 'none'
             }
@@ -38,11 +90,13 @@ class HatchetConnector {
         return hatchet;
     }
     getHatchetTask(task) {
-        return this.getHatchetClient().task({
+        const hatchetTask = this.getHatchetClient().task({
             name: task.taskName,
             retries: task.retries || 3,
-            fn: task.handle.bind(this)
+            fn: task.handle.bind(task)
         });
+        this.registeredWorkflows.set(task.taskName, hatchetTask);
+        return hatchetTask;
     }
     async startWorker({ workerName, tasks, slots = 100 }) {
         // Pre-map workflows to avoid repeated processing
@@ -59,51 +113,76 @@ class HatchetConnector {
         return worker;
     }
     /**
-     * Gets the status of a task by its name.
-     * Implements the TaskConnector interface.
-     * @param name - Name of the task.
+     * Gets the status of a task by its Hatchet run ID.
+     *
+     * Uses `runs.get()` which calls the REST API endpoint `/api/v1/stable/workflow-runs/{id}`.
+     * Includes retry logic (3 attempts with exponential backoff) to handle eventual
+     * consistency between gRPC (used by queue) and REST API (used here).
+     *
+     * The payload is double-nested in Hatchet's response: `run.input.input` contains
+     * the actual payload we passed to `queue()`.
+     *
+     * @param id - The Hatchet workflow run ID returned by `queue()`.
+     * @returns Full task status including payload, status, and metadata.
+     * @throws Error if the run cannot be found after all retry attempts.
      */
     async getStatus(id) {
-        const { data } = await this.getHatchetClient().api.v1TaskGet(id);
-        // Extract values once
-        const input = data.input;
-        const taskName = data.actionId.split(':')[0] || '';
-        return {
-            id,
-            attempts: data.attempt || 1,
-            payload: input?.input || {},
-            status: data.status,
-            created: data.metadata.createdAt,
-            name: taskName,
-            nextRun: null,
-            nextRunMinutes: null,
-            output: data.output
-        };
+        const hatchet = this.getHatchetClient();
+        const maxRetries = 3;
+        const retryDelay = 200; // ms, with exponential backoff
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const details = await hatchet.runs.get(id);
+                const run = details.run;
+                const taskName = run?.displayName?.split('-')[0] || '';
+                // Payload is double-nested: run.input.input contains actual payload
+                const inputWrapper = run?.input;
+                const payload = inputWrapper?.input || {};
+                return {
+                    id,
+                    attempts: 0,
+                    payload,
+                    status: run?.status,
+                    created: run?.metadata?.createdAt || new Date().toISOString(),
+                    name: taskName,
+                    nextRun: null,
+                    nextRunMinutes: null,
+                    output: run?.output
+                };
+            }
+            catch (error) {
+                // Retry on 404 - eventual consistency between gRPC and REST API
+                if (error?.response?.status === 404 && attempt < maxRetries - 1) {
+                    await new Promise(r => setTimeout(r, retryDelay * (attempt + 1)));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error(`Failed to get status for ${id} after ${maxRetries} attempts`);
     }
     /**
-     * Queues a task to be run in the background.
-     * Implements the TaskConnector interface.
-     * @param params
-     * @param params.taskName - Name of the task.
-     * @param params.postUrl - URL to post the task to.
-     * @param params.taskBody - Body of the task.
+     * Queues a task to be run in the background (fire-and-forget).
+     *
+     * Uses `admin.runWorkflow()` directly instead of `task.runNoWait()` to avoid
+     * the global `parentRunContextManager` state that causes race conditions
+     * when queuing tasks rapidly. See class documentation for details.
+     *
+     * @param params.taskName - Name of the task (must match a registered workflow).
+     * @param params.taskBody - The payload to pass to the task handler.
+     * @returns Task status with unique run ID. Does NOT wait for task completion.
      */
     async queue(params) {
-        const hatchet = this.getHatchetClient().task({
-            name: params.taskName,
-            retries: 3,
-            fn: params.handle.bind(this)
-        });
-        const result = await hatchet.runNoWait(params.taskBody);
-        const taskId = await result.runId;
-        const now = new Date().toISOString();
+        const hatchet = this.getHatchetClient();
+        const ref = await hatchet.admin.runWorkflow(params.taskName, params.taskBody, {});
+        const runId = await ref.getWorkflowRunId();
         return {
-            id: taskId,
-            name: result._standaloneTaskName,
+            id: runId,
+            name: ref._standaloneTaskName || params.taskName,
             output: '',
             attempts: 0,
             status: 'QUEUED',
-            created: now,
+            created: new Date().toISOString(),
             nextRun: null,
             nextRunMinutes: null
         };

package/dist/HatchetConnector.js.map

@@ -1 +1 @@
-{"version":3,"file":"HatchetConnector.js","sourceRoot":"","sources":["../src/HatchetConnector.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"HatchetConnector.js","sourceRoot":"","sources":["../src/HatchetConnector.ts"],"names":[],"mappings":"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"}

package/dist/benchmark.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hatchet Benchmark Script
+ *
+ * Run with: npx tsx src/benchmark.ts
+ *
+ * Uses testcontainers to spin up Hatchet + Postgres automatically.
+ * Total runtime: ~45-60 seconds
+ */
+export {};

package/dist/benchmark.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Hatchet Benchmark Script
+ *
+ * Run with: npx tsx src/benchmark.ts
+ *
+ * Uses testcontainers to spin up Hatchet + Postgres automatically.
+ * Total runtime: ~45-60 seconds
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tasks_core_1 = require("@goatlab/tasks-core");
+const testcontainers_1 = require("testcontainers");
+const HatchetConnector_js_1 = require("./HatchetConnector.js");
+const hatchet_js_1 = require("./test/hatchet.js");
+const postgres_js_1 = require("./test/postgres.js");
+// Configuration - keep benchmarks short
+const QUEUE_BATCH_SIZE = 50; // Smaller for Hatchet gRPC
+const WARMUP_COUNT = 20;
+const BENCHMARK_DURATION_MS = 5000; // 5 seconds
+const E2E_TASK_COUNT = 200;
+const LATENCY_SAMPLES = 20;
+class BenchmarkTask extends tasks_core_1.ShouldQueue {
+    postUrl = 'http://localhost/benchmark';
+    taskName = 'benchmark_task';
+    constructor(connector) {
+        super({ connector });
+    }
+    async handle() {
+        return undefined;
+    }
+}
+async function runQueueBenchmark(connector, task) {
+    console.log('\n📊 Queue Throughput (queue-only)');
+    console.log('='.repeat(50));
+    // Start worker (required for Hatchet)
+    await connector.startWorker({
+        tasks: [task],
+        workerName: 'benchmark-worker',
+        slots: 100
+    });
+    await new Promise(r => setTimeout(r, 2000));
+    // Warmup
+    for (let i = 0; i < WARMUP_COUNT; i++) {
+        await task.queue({ index: i });
+    }
+    console.log(`Running for ${BENCHMARK_DURATION_MS / 1000}s...`);
+    let count = 0;
+    const startTime = Date.now();
+    const endTime = startTime + BENCHMARK_DURATION_MS;
+    while (Date.now() < endTime) {
+        const promises = [];
+        for (let i = 0; i < QUEUE_BATCH_SIZE; i++) {
+            promises.push(task.queue({ index: count++ }));
+        }
+        await Promise.all(promises);
+    }
+    const elapsed = Date.now() - startTime;
+    const throughput = (count / elapsed) * 1000;
+    console.log(`✅ Queued: ${count.toLocaleString()} tasks`);
+    console.log(`✅ Throughput: ${throughput.toFixed(0)} tasks/sec`);
+    return throughput;
+}
+async function runE2EBenchmark(connector, task) {
+    console.log('\n📊 End-to-End (queue + worker)');
+    console.log('='.repeat(50));
+    await connector.startWorker({
+        tasks: [task],
+        workerName: 'e2e-worker',
+        slots: 100
+    });
+    await new Promise(r => setTimeout(r, 2000));
+    console.log(`Queuing ${E2E_TASK_COUNT} tasks...`);
+    const start = Date.now();
+    const taskIds = [];
+    // Queue tasks
+    for (let i = 0; i < E2E_TASK_COUNT; i += QUEUE_BATCH_SIZE) {
+        const batch = [];
+        for (let j = 0; j < QUEUE_BATCH_SIZE && i + j < E2E_TASK_COUNT; j++) {
+            batch.push(task.queue({ index: i + j }));
+        }
+        const results = await Promise.all(batch);
+        taskIds.push(...results.map(r => r.id));
+    }
+    const queueTime = Date.now() - start;
+    // Wait for completion by sampling (max 20s)
+    const timeout = 20000;
+    let completed = 0;
+    const waitStart = Date.now();
+    while (completed < E2E_TASK_COUNT && Date.now() - waitStart < timeout) {
+        const sampleSize = Math.min(10, taskIds.length);
+        let sampleCompleted = 0;
+        for (let i = 0; i < sampleSize; i++) {
+            try {
+                const status = await task.getStatus(taskIds[i]);
+                if (status.status === 'COMPLETED' || status.status === 'FAILED') {
+                    sampleCompleted++;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        completed = Math.floor((sampleCompleted / sampleSize) * E2E_TASK_COUNT);
+        if (completed < E2E_TASK_COUNT) {
+            await new Promise(r => setTimeout(r, 500));
+        }
+    }
+    const totalTime = Date.now() - start;
+    const throughput = (completed / totalTime) * 1000;
+    console.log(`✅ Processed: ~${completed.toLocaleString()} tasks`);
+    console.log(`✅ Queue time: ${queueTime}ms`);
+    console.log(`✅ Total time: ${totalTime}ms`);
+    console.log(`✅ Throughput: ~${throughput.toFixed(0)} tasks/sec`);
+    return throughput;
+}
+async function runLatencyBenchmark(connector, task) {
+    console.log('\n📊 Latency (round-trip)');
+    console.log('='.repeat(50));
+    await connector.startWorker({
+        tasks: [task],
+        workerName: 'latency-worker',
+        slots: 10
+    });
+    await new Promise(r => setTimeout(r, 2000));
+    const latencies = [];
+    for (let i = 0; i < LATENCY_SAMPLES; i++) {
+        const start = Date.now();
+        const status = await task.queue({ index: i });
+        // Poll for completion (max 5s per task)
+        const timeout = Date.now() + 5000;
+        while (Date.now() < timeout) {
+            try {
+                const currentStatus = await task.getStatus(status.id);
+                if (currentStatus.status === 'COMPLETED' ||
+                    currentStatus.status === 'FAILED') {
+                    latencies.push(Date.now() - start);
+                    break;
+                }
+            }
+            catch {
+                // ignore
+            }
+            await new Promise(r => setTimeout(r, 50));
+        }
+    }
+    if (latencies.length === 0) {
+        console.log('❌ No tasks completed');
+        return { avg: 0, p50: 0, p95: 0, p99: 0 };
+    }
+    latencies.sort((a, b) => a - b);
+    const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+    const p50 = latencies[Math.floor(latencies.length * 0.5)];
+    const p95 = latencies[Math.floor(latencies.length * 0.95)];
+    const p99 = latencies[Math.floor(latencies.length * 0.99)];
+    console.log(`✅ Samples: ${latencies.length}`);
+    console.log(`✅ Avg: ${avg.toFixed(1)}ms | P50: ${p50}ms | P95: ${p95}ms | P99: ${p99}ms`);
+    return { avg, p50, p95, p99 };
+}
+async function main() {
+    console.log('🚀 Hatchet Benchmark');
+    console.log('Starting containers (Postgres + Hatchet)...');
+    const network = await new testcontainers_1.Network().start();
+    const postgresContainer = await (0, postgres_js_1.getPostgres)({ network }).start();
+    const connection = {
+        host: postgresContainer.getName().replace('/', ''),
+        port: postgresContainer.getMappedPort(5432),
+        database: postgresContainer.getDatabase(),
+        user: postgresContainer.getUsername(),
+        password: postgresContainer.getPassword()
+    };
+    const postgresUri = `postgresql://${connection.user}:${connection.password}@db:5432/${connection.database}`;
+    const hatchetContainer = await (0, hatchet_js_1.getHatchetContainer)({
+        postgresConnectionString: postgresUri,
+        network: network
+    }).start();
+    const cmd = await hatchetContainer.exec('/hatchet-admin token create --config /config --tenant-id 707d0855-80ab-4e1f-a156-f1c4546cbf52 | xargs');
+    const token = cmd.stdout.trim();
+    const hostAndPort = `localhost:${hatchetContainer.getMappedPort(7077)}`;
+    const apiUrl = `http://localhost:${hatchetContainer.getMappedPort(8888)}`;
+    console.log(`Hatchet gRPC: ${hostAndPort}`);
+    console.log(`Hatchet API: ${apiUrl}`);
+    try {
+        // Queue throughput test
+        const connector1 = new HatchetConnector_js_1.HatchetConnector({
+            token,
+            hostAndPort,
+            apiUrl,
+            logLevel: 'WARN'
+        });
+        const task1 = new BenchmarkTask(connector1);
+        const queueThroughput = await runQueueBenchmark(connector1, task1);
+        // E2E test
+        const connector2 = new HatchetConnector_js_1.HatchetConnector({
+            token,
+            hostAndPort,
+            apiUrl,
+            logLevel: 'WARN'
+        });
+        const task2 = new BenchmarkTask(connector2);
+        const e2eThroughput = await runE2EBenchmark(connector2, task2);
+        // Latency test
+        const connector3 = new HatchetConnector_js_1.HatchetConnector({
+            token,
+            hostAndPort,
+            apiUrl,
+            logLevel: 'WARN'
+        });
+        const task3 = new BenchmarkTask(connector3);
+        const latency = await runLatencyBenchmark(connector3, task3);
+        // Summary
+        console.log('\n' + '='.repeat(50));
+        console.log('📈 HATCHET SUMMARY');
+        console.log('='.repeat(50));
+        console.log(`Queue throughput:  ${queueThroughput.toFixed(0)} tasks/sec`);
+        console.log(`E2E throughput:    ~${e2eThroughput.toFixed(0)} tasks/sec`);
+        console.log(`Latency (avg):     ${latency.avg.toFixed(1)}ms`);
+        console.log(`Latency (p95):     ${latency.p95}ms`);
+    }
+    finally {
+        console.log('\nStopping containers...');
+        await hatchetContainer.stop();
+        await postgresContainer.stop();
+        await network.stop();
+    }
+}
+main().catch(console.error);
+//# sourceMappingURL=benchmark.js.map