@pauly4010/evalai-sdk 1.4.1 → 1.5.5

package/dist/integrations/openai-eval.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * openAIChatEval — One-function OpenAI chat regression testing
+ *
+ * Run local regression tests with OpenAI. No EvalAI account required.
+ * CI-friendly output. Optional reportToEvalAI in v1.5.
+ *
+ * @example
+ * ```typescript
+ * import { openAIChatEval } from '@pauly4010/evalai-sdk';
+ *
+ * await openAIChatEval({
+ *   name: 'chat-regression',
+ *   cases: [
+ *     { input: 'Hello', expectedOutput: 'greeting' },
+ *     { input: '2 + 2 = ?', expectedOutput: '4' }
+ *   ]
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIChatEval = openAIChatEval;
+const assertions_1 = require("../assertions");
+const config_1 = require("../cli/config");
+const testing_1 = require("../testing");
+const input_hash_1 = require("../utils/input-hash");
+const MAX_FAILED_CASES_TO_SHOW = 5;
+function getOpenAI() {
+    try {
+        const OpenAI = require("openai");
+        return OpenAI;
+    }
+    catch {
+        throw new Error("openai package is required for openAIChatEval. Install with: npm install openai");
+    }
+}
+function createExecutor(model, apiKey) {
+    const OpenAI = getOpenAI();
+    const openai = new OpenAI({ apiKey });
+    return async (input) => {
+        const response = await openai.chat.completions.create({
+            model,
+            messages: [{ role: "user", content: input }],
+            temperature: 0.1,
+        });
+        return response.choices[0]?.message?.content ?? "";
+    };
+}
+function printSummary(result) {
+    const { passed, total, results } = result;
+    const score = total > 0 ? Math.round((passed / total) * 100) : 0;
+    const failed = results.filter((r) => !r.passed);
+    const status = failed.length === 0 ? "PASS" : "FAIL";
+    console.log(`\n${status} ${passed}/${total}  (score: ${score})\n`);
+    if (failed.length > 0) {
+        const toShow = failed.slice(0, MAX_FAILED_CASES_TO_SHOW);
+        const more = failed.length - toShow.length;
+        console.log(`${failed.length} failing case${failed.length === 1 ? "" : "s"}:`);
+        for (const r of toShow) {
+            const expected = r.expected ?? "(no expected)";
+            console.log(`- "${r.input}" → expected: ${expected}`);
+        }
+        if (more > 0) {
+            console.log(`+ ${more} more`);
+        }
+        console.log("\nGate this in CI:");
+        console.log("  npx -y @pauly4010/evalai-sdk@^1 init");
+    }
+    else {
+        console.log("Tip: Want dashboards and history?");
+        console.log("Set EVALAI_API_KEY and connect this to the platform.");
+    }
+}
+/**
+ * Run OpenAI chat regression tests locally.
+ * No EvalAI account required. Returns score and prints CI-friendly summary.
+ */
+async function openAIChatEval(options) {
+    const { name, model = "gpt-4o-mini", apiKey, cases, retries = 0 } = options;
+    const resolvedApiKey = apiKey ?? (typeof process !== "undefined" && process.env?.OPENAI_API_KEY);
+    if (!resolvedApiKey) {
+        throw new Error("OPENAI_API_KEY is required. Set it in the environment or pass apiKey to openAIChatEval.");
+    }
+    const executor = createExecutor(model, resolvedApiKey);
+    const suiteCases = cases.map((c) => {
+        const assertions = c.assertions
+            ? [...c.assertions]
+            : c.expectedOutput
+                ? [
+                    (output) => (0, assertions_1.expect)(output).toContainKeywords(c.expectedOutput.split(/\s+/).filter(Boolean)),
+                ]
+                : undefined;
+        return {
+            input: c.input,
+            expected: c.expectedOutput,
+            assertions,
+        };
+    });
+    const suite = (0, testing_1.createTestSuite)(name, {
+        cases: suiteCases,
+        executor,
+        parallel: true,
+        retries,
+    });
+    const result = await suite.run();
+    const score = result.total > 0 ? Math.round((result.passed / result.total) * 100) : 0;
+    const evalResult = {
+        passed: result.passed,
+        total: result.total,
+        score,
+        results: result.results,
+        durationMs: result.durationMs,
+        ...(result.retriedCases &&
+            result.retriedCases.length > 0 && { retriedCases: result.retriedCases }),
+    };
+    printSummary(evalResult);
+    // v1.5: Optional report to EvalAI platform
+    if (options.reportToEvalAI) {
+        const config = typeof process !== "undefined" && process.cwd ? (0, config_1.loadConfig)(process.cwd()) : null;
+        const evalId = options.evaluationId || config?.evaluationId;
+        if (!evalId || String(evalId).trim() === "") {
+            console.log("Run evalai init and set evaluationId to upload results.");
+            return evalResult;
+        }
+        const evalaiKey = (typeof process !== "undefined" && process.env?.EVALAI_API_KEY) || "";
+        if (!evalaiKey) {
+            console.log("Set EVALAI_API_KEY to upload results.");
+            return evalResult;
+        }
+        const baseUrl = options.baseUrl ||
+            config?.baseUrl ||
+            (typeof process !== "undefined" && process.env?.EVALAI_BASE_URL) ||
+            "http://localhost:3000";
+        const url = String(baseUrl).replace(/\/$/, "");
+        try {
+            // Resolve testCaseId for each result: explicit testCaseId in cases, or match by inputHash
+            const importResults = [];
+            const hasExplicitIds = cases.some((c) => c.testCaseId != null);
+            if (hasExplicitIds) {
+                // Use testCaseId from cases (same order as results)
+                for (let i = 0; i < result.results.length; i++) {
+                    const tcId = cases[i]?.testCaseId;
+                    if (tcId == null) {
+                        console.log("reportToEvalAI: All cases must have testCaseId when any has it.");
+                        return evalResult;
+                    }
+                    importResults.push({
+                        testCaseId: tcId,
+                        status: result.results[i].passed ? "passed" : "failed",
+                        output: result.results[i].actual ?? "",
+                        latencyMs: result.results[i].durationMs,
+                    });
+                }
+            }
+            else {
+                // Match by inputHash (same canonicalization as platform)
+                const tcRes = await fetch(`${url}/api/evaluations/${evalId}/test-cases?limit=500`, {
+                    headers: { Authorization: `Bearer ${evalaiKey}` },
+                });
+                if (!tcRes.ok) {
+                    console.log("Could not fetch test cases. Check evaluationId and EVALAI_API_KEY.");
+                    return evalResult;
+                }
+                const platformCases = (await tcRes.json());
+                const hashToIds = new Map();
+                for (const tc of platformCases) {
+                    const input = tc.input ?? "";
+                    if (!input.trim())
+                        continue;
+                    const hash = (0, input_hash_1.sha256Input)(input);
+                    const existing = hashToIds.get(hash) ?? [];
+                    existing.push(tc.id);
+                    hashToIds.set(hash, existing);
+                }
+                for (const r of result.results) {
+                    const hash = (0, input_hash_1.sha256Input)(r.input ?? "");
+                    const ids = hashToIds.get(hash);
+                    if (ids == null || ids.length === 0) {
+                        console.log(`No platform test case matches input: "${(r.input ?? "").slice(0, 50)}…"`);
+                        return evalResult;
+                    }
+                    if (ids.length > 1) {
+                        console.log(`Multiple platform test cases share the same input (hash collision). Use testCaseId in cases.`);
+                        return evalResult;
+                    }
+                    importResults.push({
+                        testCaseId: ids[0],
+                        status: r.passed ? "passed" : "failed",
+                        output: r.actual ?? "",
+                        latencyMs: r.durationMs,
+                    });
+                }
+            }
+            if (importResults.length !== result.results.length) {
+                console.log("Could not match all results to platform test cases.");
+                return evalResult;
+            }
+            const sdkVersion = "1.4.1";
+            const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${evalaiKey}`,
+            };
+            if (options.idempotencyKey) {
+                headers["Idempotency-Key"] = options.idempotencyKey;
+            }
+            const importRes = await fetch(`${url}/api/evaluations/${evalId}/runs/import`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    environment: "dev",
+                    results: importResults,
+                    importClientVersion: sdkVersion,
+                }),
+            });
+            if (!importRes.ok) {
+                const body = await importRes.text();
+                console.log(`Upload failed: ${importRes.status} — ${body}`);
+                return evalResult;
+            }
+            const importData = (await importRes.json());
+            if (importData.dashboardUrl) {
+                console.log(`Dashboard: ${importData.dashboardUrl}`);
+            }
+        }
+        catch (err) {
+            console.log("Upload failed:", err instanceof Error ? err.message : String(err));
+        }
+    }
+    return evalResult;
+}

package/dist/integrations/openai.d.ts

@@ -17,7 +17,7 @@
  * });
  * ```
  */
-import type { AIEvalClient } from '../client';
+import type { AIEvalClient } from "../client";
 export interface OpenAITraceOptions {
     /** Whether to capture input (default: true) */
     captureInput?: boolean;

package/dist/integrations/openai.js

@@ -41,7 +41,7 @@ const context_1 = require("../context");
  * ```
  */
 function traceOpenAI(openai, evalClient, options = {}) {
-    const { captureInput = true, captureOutput = true, captureMetadata = true, organizationId, tracePrefix = 'openai' } = options;
+    const { captureInput = true, captureOutput = true, captureMetadata = true, organizationId, tracePrefix = "openai", } = options;
     // Create proxy for chat.completions.create
     const originalCreate = openai.chat.completions.create.bind(openai.chat.completions);
     openai.chat.completions.create = async (params, requestOptions) => {
@@ -58,18 +58,20 @@ function traceOpenAI(openai, evalClient, options = {}) {
                 max_tokens: params.max_tokens,
                 ...(captureInput ? { input: params.messages } : {}),
                 ...(captureOutput ? { output: response.choices[0]?.message } : {}),
-                ...(captureMetadata ? {
-                    usage: response.usage,
-                    finish_reason: response.choices[0]?.finish_reason
-                } : {})
+                ...(captureMetadata
+                    ? {
+                        usage: response.usage,
+                        finish_reason: response.choices[0]?.finish_reason,
+                    }
+                    : {}),
             });
             await evalClient.traces.create({
                 name: `OpenAI: ${params.model}`,
                 traceId,
                 organizationId: organizationId || evalClient.getOrganizationId(),
-                status: 'success',
+                status: "success",
                 durationMs,
-                metadata: traceMetadata
+                metadata: traceMetadata,
             });
             return response;
         }
@@ -82,16 +84,18 @@ function traceOpenAI(openai, evalClient, options = {}) {
                 max_tokens: params.max_tokens,
                 ...(captureInput ? { input: params.messages } : {}),
                 ...(captureMetadata ? { params } : {}),
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
-            await evalClient.traces.create({
+            await evalClient.traces
+                .create({
                 name: `OpenAI: ${params.model}`,
                 traceId,
                 organizationId: organizationId || evalClient.getOrganizationId(),
-                status: 'error',
+                status: "error",
                 durationMs,
-                metadata: errorMetadata
-            }).catch(() => {
+                metadata: errorMetadata,
+            })
+                .catch(() => {
                 // Ignore errors in trace creation to avoid masking the original error
             });
             throw error;
@@ -124,8 +128,8 @@ async function traceOpenAICall(evalClient, name, fn, options = {}) {
             name,
             traceId,
             organizationId: options.organizationId || evalClient.getOrganizationId(),
-            status: 'pending',
-            metadata: (0, context_1.mergeWithContext)({})
+            status: "pending",
+            metadata: (0, context_1.mergeWithContext)({}),
         });
         const result = await fn();
         const durationMs = Date.now() - startTime;
@@ -133,9 +137,9 @@ async function traceOpenAICall(evalClient, name, fn, options = {}) {
             name,
             traceId,
             organizationId: options.organizationId || evalClient.getOrganizationId(),
-            status: 'success',
+            status: "success",
             durationMs,
-            metadata: (0, context_1.mergeWithContext)({})
+            metadata: (0, context_1.mergeWithContext)({}),
         });
         return result;
     }
@@ -145,11 +149,11 @@ async function traceOpenAICall(evalClient, name, fn, options = {}) {
             name,
             traceId,
             organizationId: options.organizationId || evalClient.getOrganizationId(),
-            status: 'error',
+            status: "error",
             durationMs,
             metadata: (0, context_1.mergeWithContext)({
-                error: error instanceof Error ? error.message : String(error)
-            })
+                error: error instanceof Error ? error.message : String(error),
+            }),
         });
         throw error;
     }

package/dist/local.d.ts

@@ -4,7 +4,7 @@
  *
  * ⚠️ NOTE: This module requires Node.js and will not work in browsers.
  */
-import type { Trace, Evaluation, Span } from './types';
+import type { Evaluation, Span, Trace } from "./types";
 export interface LocalStorageOptions {
     directory?: string;
     autoSave?: boolean;
@@ -30,7 +30,7 @@ export declare class LocalStorage {
     saveSpans(traceId: string, spans: Span[]): Promise<void>;
     getSpans(traceId: string): Promise<Span[] | undefined>;
     clear(): Promise<void>;
-    export(format: 'json'): Promise<string>;
+    export(_format: "json"): Promise<string>;
     getStats(): {
         traces: number;
         evaluations: number;

package/dist/local.js

@@ -11,64 +11,64 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorage = void 0;
 // Environment check
-const isNode = typeof process !== 'undefined' && process.versions?.node;
+const isNode = typeof process !== "undefined" && process.versions?.node;
 if (!isNode) {
-    throw new Error('Local storage mode requires Node.js and cannot run in browsers. ' +
-        'This feature uses the filesystem for storing data.');
+    throw new Error("Local storage mode requires Node.js and cannot run in browsers. " +
+        "This feature uses the filesystem for storing data.");
 }
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 class LocalStorage {
     constructor(options = {}) {
         this.traces = new Map();
         this.evaluations = new Map();
         this.spans = new Map();
-        this.directory = options.directory || './.evalai-data';
+        this.directory = options.directory || "./.evalai-data";
         this.autoSave = options.autoSave !== false;
         this.initialize();
     }
     async initialize() {
         try {
             await promises_1.default.mkdir(this.directory, { recursive: true });
-            await promises_1.default.mkdir(path_1.default.join(this.directory, 'traces'), { recursive: true });
-            await promises_1.default.mkdir(path_1.default.join(this.directory, 'evaluations'), { recursive: true });
-            await promises_1.default.mkdir(path_1.default.join(this.directory, 'spans'), { recursive: true });
+            await promises_1.default.mkdir(node_path_1.default.join(this.directory, "traces"), { recursive: true });
+            await promises_1.default.mkdir(node_path_1.default.join(this.directory, "evaluations"), { recursive: true });
+            await promises_1.default.mkdir(node_path_1.default.join(this.directory, "spans"), { recursive: true });
             // Load existing data
             await this.loadAllData();
         }
         catch (error) {
-            console.warn('Failed to initialize local storage:', error);
+            console.warn("Failed to initialize local storage:", error);
         }
     }
     async loadAllData() {
         try {
             // Load traces
-            const tracesDir = path_1.default.join(this.directory, 'traces');
+            const tracesDir = node_path_1.default.join(this.directory, "traces");
             const traceFiles = await promises_1.default.readdir(tracesDir);
             for (const file of traceFiles) {
-                if (file.endsWith('.json')) {
-                    const content = await promises_1.default.readFile(path_1.default.join(tracesDir, file), 'utf-8');
+                if (file.endsWith(".json")) {
+                    const content = await promises_1.default.readFile(node_path_1.default.join(tracesDir, file), "utf-8");
                     const trace = JSON.parse(content);
                     this.traces.set(trace.id.toString(), trace);
                 }
             }
             // Load evaluations
-            const evalsDir = path_1.default.join(this.directory, 'evaluations');
+            const evalsDir = node_path_1.default.join(this.directory, "evaluations");
             const evalFiles = await promises_1.default.readdir(evalsDir);
             for (const file of evalFiles) {
-                if (file.endsWith('.json')) {
-                    const content = await promises_1.default.readFile(path_1.default.join(evalsDir, file), 'utf-8');
+                if (file.endsWith(".json")) {
+                    const content = await promises_1.default.readFile(node_path_1.default.join(evalsDir, file), "utf-8");
                     const evaluation = JSON.parse(content);
                     this.evaluations.set(evaluation.id.toString(), evaluation);
                 }
             }
         }
-        catch (error) {
+        catch (_error) {
             // Directories might not exist yet, that's fine
         }
     }
     async saveTraceToDisk(trace) {
-        const filePath = path_1.default.join(this.directory, 'traces', `${trace.id}.json`);
+        const filePath = node_path_1.default.join(this.directory, "traces", `${trace.id}.json`);
         await promises_1.default.writeFile(filePath, JSON.stringify(trace, null, 2));
     }
     async saveTrace(trace) {
@@ -84,7 +84,7 @@ class LocalStorage {
         return Array.from(this.traces.values());
     }
     async saveEvaluationToDisk(evaluation) {
-        const filePath = path_1.default.join(this.directory, 'evaluations', `${evaluation.id}.json`);
+        const filePath = node_path_1.default.join(this.directory, "evaluations", `${evaluation.id}.json`);
         await promises_1.default.writeFile(filePath, JSON.stringify(evaluation, null, 2));
     }
     async saveEvaluation(evaluation) {
@@ -100,7 +100,7 @@ class LocalStorage {
         return Array.from(this.evaluations.values());
     }
     async saveSpansToDisk(traceId, spans) {
-        const filePath = path_1.default.join(this.directory, 'spans', `${traceId}.json`);
+        const filePath = node_path_1.default.join(this.directory, "spans", `${traceId}.json`);
         await promises_1.default.writeFile(filePath, JSON.stringify(spans, null, 2));
     }
     async saveSpans(traceId, spans) {
@@ -122,16 +122,16 @@ class LocalStorage {
             await this.initialize();
         }
         catch (error) {
-            console.warn('Failed to clear local storage:', error);
+            console.warn("Failed to clear local storage:", error);
         }
     }
-    async export(format) {
+    async export(_format) {
         const data = {
             traces: Array.from(this.traces.values()),
             evaluations: Array.from(this.evaluations.values()),
-            spans: Object.fromEntries(this.spans)
+            spans: Object.fromEntries(this.spans),
         };
-        const exportPath = path_1.default.join(this.directory, `export-${Date.now()}.json`);
+        const exportPath = node_path_1.default.join(this.directory, `export-${Date.now()}.json`);
         await promises_1.default.writeFile(exportPath, JSON.stringify(data, null, 2));
         return exportPath;
     }
@@ -139,7 +139,7 @@ class LocalStorage {
         return {
             traces: this.traces.size,
             evaluations: this.evaluations.size,
-            totalSpans: Array.from(this.spans.values()).reduce((sum, spans) => sum + spans.length, 0)
+            totalSpans: Array.from(this.spans.values()).reduce((sum, spans) => sum + spans.length, 0),
         };
     }
 }

package/dist/logger.d.ts

@@ -12,7 +12,7 @@
  * logger.error('Request failed', { error: err });
  * ```
  */
-export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
 export interface LoggerOptions {
     /** Log level (default: 'info') */
     level?: LogLevel;

package/dist/logger.js

@@ -23,58 +23,58 @@ const LOG_LEVELS = {
     debug: 1,
     info: 2,
     warn: 3,
-    error: 4
+    error: 4,
 };
 const LOG_COLORS = {
-    trace: '\x1b[90m', // gray
-    debug: '\x1b[36m', // cyan
-    info: '\x1b[32m', // green
-    warn: '\x1b[33m', // yellow
-    error: '\x1b[31m' // red
+    trace: "\x1b[90m", // gray
+    debug: "\x1b[36m", // cyan
+    info: "\x1b[32m", // green
+    warn: "\x1b[33m", // yellow
+    error: "\x1b[31m", // red
 };
-const COLOR_RESET = '\x1b[0m';
+const COLOR_RESET = "\x1b[0m";
 /**
  * Logger for SDK debugging and troubleshooting
  */
 class Logger {
     constructor(options = {}) {
         this.options = {
-            level: options.level || 'info',
+            level: options.level || "info",
             pretty: options.pretty ?? false,
             timestamps: options.timestamps ?? true,
             handler: options.handler || this.defaultHandler.bind(this),
-            prefix: options.prefix || 'EvalAI'
+            prefix: options.prefix || "EvalAI",
         };
     }
     /**
      * Log a trace message
      */
     trace(message, data) {
-        this.log('trace', message, data);
+        this.log("trace", message, data);
     }
     /**
      * Log a debug message
      */
     debug(message, data) {
-        this.log('debug', message, data);
+        this.log("debug", message, data);
     }
     /**
      * Log an info message
      */
     info(message, data) {
-        this.log('info', message, data);
+        this.log("info", message, data);
     }
     /**
      * Log a warning message
      */
     warn(message, data) {
-        this.log('warn', message, data);
+        this.log("warn", message, data);
     }
     /**
      * Log an error message
      */
     error(message, data) {
-        this.log('error', message, data);
+        this.log("error", message, data);
     }
     /**
      * Log HTTP request
@@ -86,7 +86,7 @@ class Logger {
      * Log HTTP response
      */
     logResponse(method, url, status, duration, data) {
-        const level = status >= 400 ? 'error' : status >= 300 ? 'warn' : 'debug';
+        const level = status >= 400 ? "error" : status >= 300 ? "warn" : "debug";
         this.log(level, `← ${method} ${url} ${status} (${duration}ms)`, data);
     }
     /**
@@ -95,7 +95,7 @@ class Logger {
     child(prefix) {
         return new Logger({
             ...this.options,
-            prefix: `${this.options.prefix}:${prefix}`
+            prefix: `${this.options.prefix}:${prefix}`,
         });
     }
     /**
@@ -118,7 +118,7 @@ class Logger {
             message,
             timestamp: new Date().toISOString(),
             data,
-            prefix: this.options.prefix
+            prefix: this.options.prefix,
         };
         this.options.handler(entry);
     }
@@ -133,23 +133,19 @@ class Logger {
         }
         // Level
         const levelStr = entry.level.toUpperCase().padEnd(5);
-        parts.push(this.options.pretty
-            ? `${LOG_COLORS[entry.level]}${levelStr}${COLOR_RESET}`
-            : levelStr);
+        parts.push(this.options.pretty ? `${LOG_COLORS[entry.level]}${levelStr}${COLOR_RESET}` : levelStr);
         // Prefix
         if (entry.prefix) {
-            parts.push(this.options.pretty
-                ? `\x1b[35m[${entry.prefix}]${COLOR_RESET}`
-                : `[${entry.prefix}]`);
+            parts.push(this.options.pretty ? `\x1b[35m[${entry.prefix}]${COLOR_RESET}` : `[${entry.prefix}]`);
         }
         // Message
         parts.push(entry.message);
         // Log
-        const logLine = parts.join(' ');
-        if (entry.level === 'error') {
+        const logLine = parts.join(" ");
+        if (entry.level === "error") {
             console.error(logLine);
         }
-        else if (entry.level === 'warn') {
+        else if (entry.level === "warn") {
             console.warn(logLine);
         }
         else {
@@ -211,7 +207,7 @@ class RequestLogger {
     logRequest(request) {
         this.logger.logRequest(request.method, request.url, {
             headers: request.headers,
-            body: request.body
+            body: request.body,
         });
     }
     /**
@@ -220,7 +216,7 @@ class RequestLogger {
     logResponse(response) {
         this.logger.logResponse(response.method, response.url, response.status, response.duration, {
             headers: response.headers,
-            body: response.body
+            body: response.body,
         });
     }
 }

package/dist/matchers/index.d.ts

@@ -0,0 +1 @@
+export { extendExpectWithToPassGate, toPassGate } from "./to-pass-gate";

package/dist/matchers/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPassGate = exports.extendExpectWithToPassGate = void 0;
+var to_pass_gate_1 = require("./to-pass-gate");
+Object.defineProperty(exports, "extendExpectWithToPassGate", { enumerable: true, get: function () { return to_pass_gate_1.extendExpectWithToPassGate; } });
+Object.defineProperty(exports, "toPassGate", { enumerable: true, get: function () { return to_pass_gate_1.toPassGate; } });