@fusionkit/ensemble 0.1.0

package/dist/external-executor.d.ts

@@ -0,0 +1,56 @@
+import type { Server } from "node:http";
+import type { JsonValue, ToolCallPlanV1, ToolExecutionRecordV1, ToolPolicyDecision } from "@fusionkit/protocol";
+import type { ToolExecutor } from "./tool-executor.js";
+export type FusionKitToolExecutionRequest = {
+    candidate_id: string;
+    tool_call_id: string;
+    plan: ToolCallPlanV1;
+    arguments: JsonValue;
+    environment_id: string;
+    tool_policy_id: string;
+};
+export type FusionKitToolExecutionBatch = {
+    requests: FusionKitToolExecutionRequest[];
+};
+export type FusionKitToolExecutionResult = {
+    candidate_id: string;
+    tool_call_id: string;
+    record: ToolExecutionRecordV1;
+    output?: JsonValue;
+    deduped: boolean;
+    decision: ToolPolicyDecision;
+};
+export type FusionKitToolExecutionResponse = {
+    results: FusionKitToolExecutionResult[];
+};
+export type FusionKitToolExecutorServerOptions = {
+    executor: ToolExecutor;
+    port: number;
+    host?: string;
+    authToken?: string;
+    maxBodyBytes?: number;
+};
+export type FusionKitToolExecutorServer = {
+    server: Server;
+    host: string;
+    port: number;
+    url: string;
+};
+export declare class FusionKitToolExecutorError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare class FusionKitToolExecutorClientError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown);
+}
+export declare class FusionKitToolExecutorClient {
+    readonly baseUrl: string;
+    private readonly authToken?;
+    constructor(baseUrl: string, authToken?: string);
+    execute(batch: FusionKitToolExecutionBatch): Promise<FusionKitToolExecutionResponse>;
+}
+export declare function executeFusionKitToolBatch(executor: ToolExecutor, batch: unknown): Promise<FusionKitToolExecutionResponse>;
+export declare function startFusionKitToolExecutorServer(options: FusionKitToolExecutorServerOptions): Promise<FusionKitToolExecutorServer>;

package/dist/external-executor.js

@@ -0,0 +1,288 @@
+import { createServer } from "node:http";
+import { assertToolCallPlanV1, toolArgumentsHash, toolSideEffectClassFromModelFusion } from "@fusionkit/protocol";
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+const HEALTH_RESPONSE = { ok: true, service: "warrant-tool-executor" };
+export class FusionKitToolExecutorError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "FusionKitToolExecutorError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export class FusionKitToolExecutorClientError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        const message = typeof body === "object" && body !== null && "error" in body
+            ? String(body.error)
+            : `tool executor request failed with status ${status}`;
+        super(message);
+        this.name = "FusionKitToolExecutorClientError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export class FusionKitToolExecutorClient {
+    baseUrl;
+    authToken;
+    constructor(baseUrl, authToken) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.authToken = authToken;
+    }
+    async execute(batch) {
+        const headers = {
+            "content-type": "application/json"
+        };
+        if (this.authToken)
+            headers.authorization = `Bearer ${this.authToken}`;
+        const response = await fetch(`${this.baseUrl}/v1/fusionkit/tool-executions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(batch)
+        });
+        const payload = await parseJsonResponse(response);
+        if (!response.ok) {
+            throw new FusionKitToolExecutorClientError(response.status, payload);
+        }
+        return parseFusionKitToolExecutionResponse(payload);
+    }
+}
+export async function executeFusionKitToolBatch(executor, batch) {
+    const parsed = parseFusionKitToolExecutionBatch(batch);
+    const results = [];
+    for (const request of parsed.requests) {
+        validateRequestPolicy(executor, request);
+        validatePlanArguments(request);
+        const sideEffects = sideEffectsForPlan(request.plan);
+        const result = await executor.execute({
+            candidate_id: request.candidate_id,
+            plan_id: request.plan.plan_id,
+            tool_name: request.plan.tool_name,
+            arguments: request.arguments,
+            side_effects: sideEffects
+        });
+        results.push({
+            candidate_id: request.candidate_id,
+            tool_call_id: request.tool_call_id,
+            record: result.record,
+            ...(result.output !== undefined ? { output: result.output } : {}),
+            deduped: result.deduped,
+            decision: result.decision
+        });
+    }
+    return { results };
+}
+export function startFusionKitToolExecutorServer(options) {
+    const { executor, port, host = "127.0.0.1" } = options;
+    const context = {
+        executor,
+        authToken: options.authToken,
+        maxBodyBytes: options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES
+    };
+    const server = createServer((req, res) => {
+        handleRequest(context, req, res).catch((error) => {
+            if (error instanceof FusionKitToolExecutorError) {
+                sendJson(res, error.status, { error: error.message, code: error.code });
+                return;
+            }
+            sendJson(res, 500, { error: "internal server error", code: "internal_error" });
+        });
+    });
+    return new Promise((resolve) => {
+        server.listen(port, host, () => {
+            const address = server.address();
+            const boundPort = typeof address === "object" && address !== null ? address.port : port;
+            resolve({
+                server,
+                host,
+                port: boundPort,
+                url: `http://${host}:${boundPort}`
+            });
+        });
+    });
+}
+async function handleRequest(context, req, res) {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (method === "GET" && url.pathname === "/v1/health") {
+        sendJson(res, 200, HEALTH_RESPONSE);
+        return;
+    }
+    if (method === "POST" && url.pathname === "/v1/fusionkit/tool-executions") {
+        requireAuth(context, req);
+        const body = await readJson(req, context.maxBodyBytes);
+        const response = await executeFusionKitToolBatch(context.executor, body);
+        sendJson(res, 200, response);
+        return;
+    }
+    sendJson(res, 404, { error: "not found", code: "not_found" });
+}
+function validateRequestPolicy(executor, request) {
+    if (request.environment_id !== executor.contract.environment_id) {
+        throw new FusionKitToolExecutorError(403, "environment_mismatch", "request environment_id does not match executor environment");
+    }
+    if (request.tool_policy_id !== executor.contract.tool_policy_id) {
+        throw new FusionKitToolExecutorError(403, "policy_mismatch", "request tool_policy_id does not match executor policy");
+    }
+}
+function validatePlanArguments(request) {
+    const argumentsHash = toolArgumentsHash(request.arguments);
+    if (request.plan.arguments_hash !== argumentsHash) {
+        throw new FusionKitToolExecutorError(400, "arguments_hash_mismatch", "tool-call-plan arguments_hash does not match request arguments");
+    }
+}
+function parseFusionKitToolExecutionBatch(value) {
+    const object = assertRecord(value, "batch");
+    assertKnownKeys(object, ["requests"], "batch");
+    if (!Array.isArray(object.requests)) {
+        throw invalid("batch.requests must be an array");
+    }
+    return {
+        requests: object.requests.map((request, index) => parseFusionKitToolExecutionRequest(request, `batch.requests[${index}]`))
+    };
+}
+function parseFusionKitToolExecutionRequest(value, context) {
+    const object = assertRecord(value, context);
+    assertKnownKeys(object, ["candidate_id", "tool_call_id", "plan", "arguments", "environment_id", "tool_policy_id"], context);
+    assertString(object.candidate_id, `${context}.candidate_id`);
+    assertString(object.tool_call_id, `${context}.tool_call_id`);
+    assertString(object.environment_id, `${context}.environment_id`);
+    assertString(object.tool_policy_id, `${context}.tool_policy_id`);
+    assertJsonValue(object.arguments, `${context}.arguments`);
+    try {
+        assertToolCallPlanV1(object.plan);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalid(`${context}.plan invalid: ${message}`);
+    }
+    return {
+        candidate_id: object.candidate_id,
+        tool_call_id: object.tool_call_id,
+        plan: object.plan,
+        arguments: object.arguments,
+        environment_id: object.environment_id,
+        tool_policy_id: object.tool_policy_id
+    };
+}
+function parseFusionKitToolExecutionResponse(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new FusionKitToolExecutorClientError(500, {
+            error: "tool executor response must be an object"
+        });
+    }
+    const object = value;
+    if (!Array.isArray(object.results)) {
+        throw new FusionKitToolExecutorClientError(500, {
+            error: "tool executor response results must be an array"
+        });
+    }
+    return value;
+}
+function sideEffectsForPlan(plan) {
+    try {
+        return toolSideEffectClassFromModelFusion(plan.side_effects);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalid(message);
+    }
+}
+function assertRecord(value, context) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw invalid(`${context} must be an object`);
+    }
+    return value;
+}
+function assertKnownKeys(object, allowed, context) {
+    for (const key of Object.keys(object)) {
+        if (!allowed.includes(key)) {
+            throw invalid(`${context}.${key} is not supported`);
+        }
+    }
+}
+function assertString(value, context) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw invalid(`${context} must be a non-empty string`);
+    }
+}
+function assertJsonValue(value, context) {
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+        return;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw invalid(`${context} must be JSON-safe`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertJsonValue(item, `${context}[${index}]`));
+        return;
+    }
+    if (typeof value === "object") {
+        for (const [key, item] of Object.entries(value)) {
+            assertJsonValue(item, `${context}.${key}`);
+        }
+        return;
+    }
+    throw invalid(`${context} must be JSON-safe`);
+}
+function invalid(message) {
+    return new FusionKitToolExecutorError(400, "invalid_request", message);
+}
+function readBody(req, maxBodyBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBodyBytes) {
+                reject(new FusionKitToolExecutorError(413, "body_too_large", "body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+async function readJson(req, maxBodyBytes) {
+    const raw = (await readBody(req, maxBodyBytes)).toString("utf8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new FusionKitToolExecutorError(400, "invalid_json", "request body is not valid JSON");
+    }
+}
+async function parseJsonResponse(response) {
+    const text = await response.text();
+    if (text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { error: text };
+    }
+}
+function requireAuth(context, req) {
+    if (context.authToken === undefined)
+        return;
+    const header = req.headers.authorization;
+    if (header !== `Bearer ${context.authToken}`) {
+        throw new FusionKitToolExecutorError(401, "unauthorized", "invalid bearer token");
+    }
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(payload)
+    });
+    res.end(payload);
+}

package/dist/harness.d.ts

@@ -0,0 +1,337 @@
+import type { ArtifactRef, HarnessCandidateRecordV1, HarnessRunRequestV1, HarnessRunResultV1, JudgeSynthesisRecordV1, JsonValue, ModelFusionHarnessKind, ModelCallRecordV1, ModelFusionCapabilityStatus, ModelFusionSideEffects, ModelFusionStatus, ToolExecutionRecordV1 } from "@fusionkit/protocol";
+import type { CandidateWorktree } from "./worktree.js";
+import type { JudgeSynthesizer, SynthesisFailureSummary, SynthesisRepairAttempt } from "./judge.js";
+export type EnsembleModel = {
+    id: string;
+    model: string;
+    endpointId?: string;
+};
+export type TrajectoryStepType = "reasoning" | "tool_call" | "observation" | "output";
+/** One step of an agent trajectory (mirrors harness-trajectory.v1 steps). */
+export type TrajectoryStep = {
+    index: number;
+    type: TrajectoryStepType;
+    text?: string;
+    tool_name?: string;
+    tool_call_id?: string;
+    tool_input?: string;
+    is_error?: boolean;
+};
+export type TrajectoryVerification = {
+    status: ModelFusionStatus;
+    evidence: string[];
+    exitCode?: number;
+};
+/**
+ * A normalized agent trajectory produced by one panel model: the ordered
+ * reasoning/tool-call/observation/output sequence plus the final output and
+ * any verification. This is the unit of trajectory-level fusion.
+ */
+export type HarnessTrajectory = {
+    trajectoryId: string;
+    modelId: string;
+    model?: string;
+    candidateId?: string;
+    harnessKind?: ModelFusionHarnessKind;
+    status: ModelFusionStatus;
+    steps: TrajectoryStep[];
+    finalOutput: string;
+    diff?: string;
+    verification?: TrajectoryVerification;
+};
+export type CandidateIsolationKind = "process" | "container" | "microvm";
+export type CandidateActualIsolationKind = CandidateIsolationKind | "vercel-sandbox";
+export type CandidateIsolationNetworkPolicy = {
+    defaultDeny: boolean;
+    allowHosts: string[];
+    enforce?: boolean;
+};
+export type CandidateIsolationMountPolicy = {
+    workdir?: string;
+    worktreeWritable?: boolean;
+    readOnlyCachePaths?: string[];
+    ignoredDirs?: string[];
+};
+export type CandidateIsolationSecretPolicy = {
+    secretNames?: string[];
+    secretValueHashes?: string[];
+    injectedEnvNames?: string[];
+};
+export type CandidateContainerDriverInput = {
+    command: string;
+    cwd: string;
+    timeoutMs?: number;
+    image: string;
+    workdir: string;
+    mountPolicy: Required<CandidateIsolationMountPolicy>;
+    networkPolicy: Required<CandidateIsolationNetworkPolicy>;
+};
+export type CandidateContainerDriverResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut?: boolean;
+    cleanup?: {
+        attempted: boolean;
+        succeeded: boolean;
+        error?: string;
+    };
+};
+export type CandidateContainerDriver = {
+    id: string;
+    supportsNetworkPolicy: boolean;
+    execute(input: CandidateContainerDriverInput): Promise<CandidateContainerDriverResult> | CandidateContainerDriverResult;
+};
+export type CandidateMicrovmProvider = "vercel-sandbox" | (string & {});
+export type CandidateMicrovmRuntimeMetadata = {
+    provider?: CandidateMicrovmProvider;
+    runtime?: string;
+    snapshotId?: string;
+    sandboxId?: string;
+    imageDigest?: string;
+    runtimeDigest?: string;
+};
+export type CandidateMicrovmDriverInput = {
+    command: string;
+    cwd: string;
+    timeoutMs?: number;
+    provider: CandidateMicrovmProvider;
+    runtime: string;
+    snapshotId?: string;
+    workdir: string;
+    mountPolicy: Required<CandidateIsolationMountPolicy>;
+    networkPolicy: Required<CandidateIsolationNetworkPolicy>;
+    secretPolicy: Required<CandidateIsolationSecretPolicy>;
+};
+export type CandidateMicrovmDriverResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut?: boolean;
+    actualIsolation?: Extract<CandidateActualIsolationKind, "microvm" | "vercel-sandbox">;
+    runtime?: CandidateMicrovmRuntimeMetadata;
+    cleanup?: {
+        attempted: boolean;
+        succeeded: boolean;
+        timedOut?: boolean;
+        error?: string;
+    };
+};
+export type CandidateMicrovmDriver = {
+    id: string;
+    provider: CandidateMicrovmProvider;
+    supportsNetworkPolicy: boolean;
+    execute(input: CandidateMicrovmDriverInput): Promise<CandidateMicrovmDriverResult> | CandidateMicrovmDriverResult;
+};
+export type CandidateIsolationConfig = {
+    kind: "process";
+    networkPolicy?: CandidateIsolationNetworkPolicy;
+    mountPolicy?: CandidateIsolationMountPolicy;
+    secretPolicy?: CandidateIsolationSecretPolicy;
+} | {
+    kind: "container";
+    image?: string;
+    engine?: "docker" | "podman";
+    driver?: CandidateContainerDriver;
+    networkPolicy?: CandidateIsolationNetworkPolicy;
+    mountPolicy?: CandidateIsolationMountPolicy;
+    secretPolicy?: CandidateIsolationSecretPolicy;
+} | {
+    kind: "microvm";
+    provider?: CandidateMicrovmProvider;
+    runtime?: string;
+    snapshotId?: string;
+    sandboxId?: string;
+    imageDigest?: string;
+    runtimeDigest?: string;
+    driver?: CandidateMicrovmDriver;
+    networkPolicy?: CandidateIsolationNetworkPolicy;
+    mountPolicy?: CandidateIsolationMountPolicy;
+    secretPolicy?: CandidateIsolationSecretPolicy;
+};
+export type CandidateHardeningMetadata = {
+    requested_isolation: CandidateIsolationKind;
+    actual_isolation: CandidateActualIsolationKind;
+    runtime: {
+        image?: string;
+        driver?: string;
+        provider?: CandidateMicrovmProvider;
+        runtime?: string;
+        snapshot_id?: string;
+        sandbox_id?: string;
+        image_digest?: string;
+        runtime_digest?: string;
+        workdir: string;
+    };
+    mount_policy: {
+        worktree_writable: boolean;
+        read_only_caches: string[];
+        ignored_dirs: string[];
+    };
+    network_policy: {
+        default_deny: boolean;
+        allow_hosts: string[];
+        enforced: boolean;
+    };
+    cleanup: {
+        attempted: boolean;
+        succeeded: boolean;
+        status: "not_required" | "succeeded" | "failed" | "timed_out";
+        timed_out?: boolean;
+        error?: string;
+    };
+    secret_absence: {
+        secret_names: string[];
+        secret_value_hashes: string[];
+        injected_env_names: string[];
+        scanned: boolean;
+        leaks_found: boolean;
+        scan_scope: string[];
+        leak_count: number;
+    };
+};
+export type EnsembleRuntime = {
+    id: string;
+    environmentId?: string;
+    isolation?: CandidateIsolationConfig;
+};
+export type EnsembleJudge = {
+    id: string;
+    model?: string;
+    synthesizer?: JudgeSynthesizer;
+};
+export type EnsemblePolicy = {
+    id: string;
+    allowedTools: string[];
+    sideEffects: ModelFusionSideEffects;
+    timeoutMs?: number;
+    budgetUsd?: number;
+};
+export type VerificationProfile = {
+    id: string;
+    command?: string;
+    requiredEvidence: string[];
+};
+export type HarnessCapabilities = Record<string, ModelFusionCapabilityStatus>;
+export type HarnessArtifact = ArtifactRef;
+export type HarnessToolRecord = Pick<ToolExecutionRecordV1, "execution_id" | "plan_id" | "status" | "output_hash" | "error">;
+export type HarnessCandidateOutput = {
+    candidateId?: string;
+    model: EnsembleModel;
+    status: ModelFusionStatus;
+    modelCallId?: string;
+    modelCallRecord?: ModelCallRecordV1;
+    branchName?: string;
+    worktreePath?: string;
+    transcript?: string;
+    trajectory?: HarnessTrajectory;
+    diff?: string;
+    log?: string;
+    summary?: string;
+    screenshots?: HarnessArtifact[];
+    score?: number;
+    artifacts?: HarnessArtifact[];
+    toolRecords?: HarnessToolRecord[];
+    verification?: {
+        status: ModelFusionStatus;
+        evidence: string[];
+        exitCode?: number;
+    };
+    error?: HarnessCandidateRecordV1["error"];
+    metadata?: Record<string, JsonValue>;
+};
+export type HarnessPrepareInput = {
+    descriptor: EnsembleDescriptor;
+    request: HarnessRunRequestV1;
+};
+export type HarnessRunInput = {
+    descriptor: EnsembleDescriptor;
+    request: HarnessRunRequestV1;
+    model: EnsembleModel;
+    ordinal: number;
+    prepared: unknown;
+    worktree?: CandidateWorktree;
+};
+export type HarnessCollectInput = {
+    descriptor: EnsembleDescriptor;
+    request: HarnessRunRequestV1;
+    candidates: readonly HarnessCandidateOutput[];
+    prepared: unknown;
+};
+export type HarnessAdapter = {
+    id: string;
+    harnessKind?: ModelFusionHarnessKind;
+    prepare(input: HarnessPrepareInput): Promise<unknown> | unknown;
+    run(input: HarnessRunInput): Promise<HarnessCandidateOutput> | HarnessCandidateOutput;
+    collectArtifacts(input: HarnessCollectInput): Promise<HarnessArtifact[]> | HarnessArtifact[];
+    cleanup?(input: HarnessCollectInput): Promise<void> | void;
+    verificationProfile(descriptor: EnsembleDescriptor): VerificationProfile;
+    capabilities(descriptor: EnsembleDescriptor): HarnessCapabilities;
+};
+export type ReviewEvidence = {
+    strategy: string;
+    scorecards: Record<string, JsonValue>[];
+    reason?: string;
+};
+export type EnsembleDescriptor = {
+    id: string;
+    harness: HarnessAdapter;
+    models: EnsembleModel[];
+    runtime: EnsembleRuntime;
+    judge: EnsembleJudge;
+    policy: EnsemblePolicy;
+    prompt: string;
+    sourceRepo: string;
+    baseGitSha: string;
+    workspace?: string;
+    outputRoot?: string;
+    cleanupWorktrees?: boolean;
+    metadata?: Record<string, JsonValue>;
+    reviewEvidence?: ReviewEvidence;
+    checks?: never;
+};
+export type EnsembleRunResult = {
+    descriptorId: string;
+    harnessRunRequest: HarnessRunRequestV1;
+    harnessRunResult: HarnessRunResultV1;
+    candidates: readonly HarnessCandidateRecordV1[];
+    artifacts: readonly HarnessArtifact[];
+    toolRecords: readonly HarnessToolRecord[];
+    modelCallRecords: readonly ModelCallRecordV1[];
+    verification: VerificationProfile;
+    summaryPath?: string;
+    summary?: EnsembleRunSummary;
+    judgeSynthesisRecord?: JudgeSynthesisRecordV1;
+    finalPatchPath?: string | null;
+    repairAttempts?: readonly SynthesisRepairAttempt[];
+    failureSummary?: SynthesisFailureSummary;
+    reviewEvidence?: ReviewEvidence;
+};
+export type EnsembleCandidateSummary = {
+    candidateId: string;
+    modelId: string;
+    model: string;
+    modelCallId?: string;
+    status: ModelFusionStatus;
+    branchName?: string;
+    worktreePath?: string;
+    toolExecutionIds: string[];
+    diffArtifacts: HarnessArtifact[];
+    verification?: HarnessCandidateOutput["verification"];
+    hardening?: CandidateHardeningMetadata;
+};
+export type EnsembleRunSummary = {
+    descriptorId: string;
+    snapshot?: {
+        baseGitSha: string;
+        snapshotHash: string;
+        workspace: string;
+    };
+    candidates: EnsembleCandidateSummary[];
+    artifacts: HarnessArtifact[];
+    modelCallRecords: ModelCallRecordV1[];
+    judgeSynthesisRecord?: JudgeSynthesisRecordV1;
+    finalPatchPath: string | null;
+    repairAttempts?: SynthesisRepairAttempt[];
+    failureSummary?: SynthesisFailureSummary;
+};

package/dist/harness.js

@@ -0,0 +1 @@
+export {};