agent-ablation 0.2.0 → 0.3.0

package/dist/index.js

@@ -51,10 +51,220 @@ function fromRecords(records, options) {
   });
 }
 
+// src/adapters/crewai.ts
+function fromCrewAITasks(outputs, options = {}) {
+  const findings = [];
+  for (const output of outputs) {
+    if (!output || typeof output !== "object") continue;
+    let agentId;
+    if (options.agentIdOf) {
+      agentId = options.agentIdOf(output);
+    } else if (typeof output.agent === "string") {
+      agentId = output.agent;
+    } else if (typeof output.agent === "object" && output.agent !== null) {
+      agentId = output.agent.role || output.agent.name;
+    }
+    if (!agentId || agentId.trim().length === 0) continue;
+    let score = 0;
+    if (options.scoreOf) {
+      score = options.scoreOf(output);
+    } else if (typeof output.score === "number") {
+      score = output.score;
+    } else if (output.json_dict && typeof output.json_dict.score === "number") {
+      score = output.json_dict.score;
+    }
+    const confidence = options.confidenceOf ? options.confidenceOf(output) : output.json_dict && typeof output.json_dict.confidence === "number" ? output.json_dict.confidence : void 0;
+    const cost = options.costOf ? options.costOf(output) : typeof output.cost === "number" ? output.cost : void 0;
+    const tokens = options.tokensOf ? options.tokensOf(output) : typeof output.tokens === "number" ? output.tokens : void 0;
+    const latencyMs = typeof output.latencyMs === "number" ? output.latencyMs : void 0;
+    const metadata = {
+      ...output.json_dict || {},
+      ...output.raw ? { raw: output.raw } : {}
+    };
+    const finding = {
+      agentId: agentId.trim(),
+      score,
+      metadata
+    };
+    if (confidence !== void 0) finding.confidence = confidence;
+    if (cost !== void 0) finding.cost = cost;
+    if (tokens !== void 0) finding.tokens = tokens;
+    if (latencyMs !== void 0) finding.latencyMs = latencyMs;
+    findings.push(finding);
+  }
+  return findings;
+}
+
+// src/adapters/autogen.ts
+function fromAutoGenMessages(messages, options) {
+  const findings = [];
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    const agentId = message.name || (message.role && message.role !== "user" && message.role !== "system" ? message.role : void 0);
+    if (!agentId || agentId.trim().length === 0) continue;
+    const score = options.scoreOf(message);
+    const confidence = options.confidenceOf ? options.confidenceOf(message) : void 0;
+    const tokens = options.tokensOf ? options.tokensOf(message) : void 0;
+    const cost = options.costOf ? options.costOf(message) : void 0;
+    let metadata = {};
+    if (typeof message.content === "object" && message.content !== null && !Array.isArray(message.content)) {
+      metadata = { ...message.content };
+    } else if (message.content !== void 0) {
+      metadata = { raw: message.content };
+    }
+    if (message.context) {
+      metadata.context = message.context;
+    }
+    const finding = {
+      agentId: agentId.trim(),
+      score,
+      metadata
+    };
+    if (confidence !== void 0) finding.confidence = confidence;
+    if (tokens !== void 0) finding.tokens = tokens;
+    if (cost !== void 0) finding.cost = cost;
+    findings.push(finding);
+  }
+  return findings;
+}
+
+// src/adapters/vercel.ts
+function fromAISDKSteps(steps, options) {
+  const findings = [];
+  for (const step of steps) {
+    if (!step || typeof step !== "object") continue;
+    const agentId = options.agentIdOf ? options.agentIdOf(step) : step.toolName || step.stepType;
+    if (!agentId || agentId.trim().length === 0) continue;
+    const score = options.scoreOf(step);
+    const confidence = options.confidenceOf ? options.confidenceOf(step) : void 0;
+    const tokens = step.usage?.totalTokens ?? ((step.usage?.promptTokens || 0) + (step.usage?.completionTokens || 0) || void 0);
+    const cost = options.costOf ? options.costOf(step) : void 0;
+    const latencyMs = typeof step.latencyMs === "number" ? step.latencyMs : void 0;
+    let metadata = {};
+    if (typeof step.result === "object" && step.result !== null && !Array.isArray(step.result)) {
+      metadata = { ...step.result };
+    } else if (step.result !== void 0) {
+      metadata = { result: step.result };
+    }
+    if (step.args) {
+      metadata.args = step.args;
+    }
+    const finding = {
+      agentId: agentId.trim(),
+      score,
+      metadata
+    };
+    if (confidence !== void 0) finding.confidence = confidence;
+    if (tokens !== void 0) finding.tokens = tokens;
+    if (cost !== void 0) finding.cost = cost;
+    if (latencyMs !== void 0) finding.latencyMs = latencyMs;
+    findings.push(finding);
+  }
+  return findings;
+}
+
+// src/reporters/index.ts
+function formatMarkdownReport(summary, options = {}) {
+  const title = options.title || "Agent Ablation & ROI Evaluation Report";
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push("");
+  lines.push(`- **Evaluated Cases:** ${summary.cases}`);
+  lines.push(`- **Average Load-Bearing Ratio:** ${(summary.averageLoadBearingRatio * 100).toFixed(1)}%`);
+  if (summary.accuracy !== void 0) {
+    lines.push(`- **Baseline Accuracy:** ${(summary.accuracy.baselineAccuracy * 100).toFixed(1)}%`);
+  }
+  lines.push("");
+  lines.push("### Per-Agent Influence Breakdown");
+  lines.push("");
+  lines.push("| Agent ID | Appearances | Verdict Flips | Influence Share | Net Accuracy Impact |");
+  lines.push("| :--- | :--- | :--- | :--- | :--- |");
+  const agentIds = Object.keys(summary.perAgentInfluence);
+  for (const id of agentIds) {
+    const influence = summary.perAgentInfluence[id] ?? 0;
+    const stats = summary.perAgentStats?.[id];
+    const appearances = stats?.appearances ?? "-";
+    const flips = stats?.flips ?? "-";
+    let netAccStr = "N/A";
+    if (stats?.netAccuracyImpact !== void 0) {
+      const sign = stats.netAccuracyImpact > 0 ? "+" : "";
+      netAccStr = `${sign}${(stats.netAccuracyImpact * 100).toFixed(1)}% (${stats.role || "Neutral"})`;
+    }
+    lines.push(
+      `| \`${id}\` | ${appearances} | ${flips} | ${(influence * 100).toFixed(1)}% | ${netAccStr} |`
+    );
+  }
+  lines.push("");
+  if (summary.roi && options.includeRoi !== false) {
+    lines.push("### Cost & Telemetry ROI Analysis");
+    lines.push("");
+    lines.push("| Agent ID | Total Cost | Total Tokens | Cost / Verdict Flip | Cost Share | ROI Efficiency |");
+    lines.push("| :--- | :--- | :--- | :--- | :--- | :--- |");
+    for (const [id, agentRoi] of Object.entries(summary.roi.agents)) {
+      const costStr = agentRoi.totalCost !== void 0 ? `$${agentRoi.totalCost.toFixed(4)}` : "N/A";
+      const tokenStr = agentRoi.totalTokens !== void 0 ? agentRoi.totalTokens.toLocaleString() : "N/A";
+      const costPerFlipStr = agentRoi.costPerVerdictFlip !== void 0 ? `$${agentRoi.costPerVerdictFlip.toFixed(4)}` : "N/A";
+      const costShareStr = agentRoi.costShare !== void 0 ? `${(agentRoi.costShare * 100).toFixed(1)}%` : "N/A";
+      const roiEffStr = agentRoi.efficiencyRatio !== void 0 ? `${agentRoi.efficiencyRatio.toFixed(2)}x` : "N/A";
+      lines.push(
+        `| \`${id}\` | ${costStr} | ${tokenStr} | ${costPerFlipStr} | ${costShareStr} | ${roiEffStr} |`
+      );
+    }
+    lines.push("");
+  }
+  if (summary.roi?.recommendations && summary.roi.recommendations.length > 0 && options.includeRecommendations !== false) {
+    lines.push("### Optimization & Pruning Recommendations");
+    lines.push("");
+    for (const rec of summary.roi.recommendations) {
+      lines.push(`- \u26A0\uFE0F **\`${rec.agentId}\`**: ${rec.reason}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatAsciiTable(summary) {
+  const lines = [];
+  lines.push("================ AGENT ABLATION SUMMARY ================");
+  lines.push(`Cases: ${summary.cases} | Mean Load-Bearing Ratio: ${(summary.averageLoadBearingRatio * 100).toFixed(1)}%`);
+  lines.push("--------------------------------------------------------");
+  lines.push("Agent ID                | Flips | Influence | Cost/Flip");
+  lines.push("--------------------------------------------------------");
+  for (const [id, influence] of Object.entries(summary.perAgentInfluence)) {
+    const paddedId = id.padEnd(23, " ").slice(0, 23);
+    const stats = summary.perAgentStats?.[id];
+    const flips = stats ? `${stats.flips}/${stats.appearances}`.padEnd(5, " ") : "N/A  ";
+    const infStr = `${(influence * 100).toFixed(1)}%`.padEnd(9, " ");
+    const agentRoi = summary.roi?.agents[id];
+    const costPerFlip = agentRoi?.costPerVerdictFlip !== void 0 ? `$${agentRoi.costPerVerdictFlip.toFixed(3)}` : "N/A";
+    lines.push(`${paddedId} | ${flips} | ${infStr} | ${costPerFlip}`);
+  }
+  lines.push("========================================================");
+  return lines.join("\n");
+}
+
 // src/index.ts
 function defaultEquals(a, b) {
   return a === b;
 }
+function majorityVote(samples, equals = defaultEquals) {
+  if (samples.length === 0) {
+    throw new Error("Cannot compute majority vote of empty sample array");
+  }
+  if (samples.length === 1) {
+    return samples[0];
+  }
+  const clusters = [];
+  for (const sample of samples) {
+    const existing = clusters.find((c) => equals(c.value, sample));
+    if (existing) {
+      existing.count += 1;
+    } else {
+      clusters.push({ value: sample, count: 1 });
+    }
+  }
+  clusters.sort((a, b) => b.count - a.count);
+  return clusters[0].value;
+}
 function runAblation(findings, decide, equals = defaultEquals) {
   const baseline = decide(findings.slice());
   const perAgent = findings.map((finding, index) => {
@@ -77,34 +287,339 @@ function runAblation(findings, decide, equals = defaultEquals) {
     loadBearingRatio
   };
 }
-function batchAblation(cases, decide, equals = defaultEquals) {
-  const results = cases.map((findings) => runAblation(findings, decide, equals));
+async function runAblationAsync(findings, decide, options = {}) {
+  const equals = options.equals || defaultEquals;
+  const samples = options.samples ?? 1;
+  async function evaluate(fs) {
+    if (samples <= 1) {
+      return await decide(fs.slice());
+    }
+    const sampleResults = [];
+    for (let i = 0; i < samples; i++) {
+      sampleResults.push(await decide(fs.slice()));
+    }
+    return options.aggregateSamples ? options.aggregateSamples(sampleResults) : majorityVote(sampleResults, equals);
+  }
+  const baseline = await evaluate(findings);
+  const perAgent = [];
+  for (let index = 0; index < findings.length; index++) {
+    const finding = findings[index];
+    const without = findings.slice(0, index).concat(findings.slice(index + 1));
+    const verdictWithout = await evaluate(without);
+    perAgent.push({
+      removedAgentId: finding.agentId,
+      verdictWithout,
+      changed: !equals(baseline, verdictWithout)
+    });
+  }
+  const totalAgents = findings.length;
+  const loadBearingCount = perAgent.filter((p) => p.changed).length;
+  const loadBearingRatio = totalAgents === 0 ? 0 : loadBearingCount / totalAgents;
+  return {
+    baseline,
+    perAgent,
+    loadBearingCount,
+    totalAgents,
+    loadBearingRatio
+  };
+}
+function aggregateBatchResults(cases, results, options = {}) {
+  const equals = options.equals || defaultEquals;
   const appearances = /* @__PURE__ */ new Map();
   const changedCounts = /* @__PURE__ */ new Map();
-  for (const result of results) {
+  const protectiveCounts = /* @__PURE__ */ new Map();
+  const correctiveCounts = /* @__PURE__ */ new Map();
+  const totalCostByAgent = /* @__PURE__ */ new Map();
+  const totalTokensByAgent = /* @__PURE__ */ new Map();
+  const totalLatencyByAgent = /* @__PURE__ */ new Map();
+  let hasTelemetry = false;
+  for (let caseIdx = 0; caseIdx < cases.length; caseIdx++) {
+    const caseFindings = cases[caseIdx];
+    const result = results[caseIdx];
+    const gt = options.groundTruth ? options.groundTruth[caseIdx] : void 0;
+    const baselineCorrect = gt !== void 0 ? equals(result.baseline, gt) : void 0;
+    for (const f of caseFindings) {
+      if (f.cost !== void 0) {
+        totalCostByAgent.set(f.agentId, (totalCostByAgent.get(f.agentId) ?? 0) + f.cost);
+        hasTelemetry = true;
+      }
+      if (f.tokens !== void 0) {
+        totalTokensByAgent.set(f.agentId, (totalTokensByAgent.get(f.agentId) ?? 0) + f.tokens);
+        hasTelemetry = true;
+      }
+      if (f.latencyMs !== void 0) {
+        totalLatencyByAgent.set(f.agentId, (totalLatencyByAgent.get(f.agentId) ?? 0) + f.latencyMs);
+        hasTelemetry = true;
+      }
+    }
     for (const perAgent of result.perAgent) {
       const id = perAgent.removedAgentId;
       appearances.set(id, (appearances.get(id) ?? 0) + 1);
       if (perAgent.changed) {
         changedCounts.set(id, (changedCounts.get(id) ?? 0) + 1);
       }
+      if (gt !== void 0 && baselineCorrect !== void 0) {
+        const withoutCorrect = equals(perAgent.verdictWithout, gt);
+        if (baselineCorrect && !withoutCorrect) {
+          protectiveCounts.set(id, (protectiveCounts.get(id) ?? 0) + 1);
+        } else if (!baselineCorrect && withoutCorrect) {
+          correctiveCounts.set(id, (correctiveCounts.get(id) ?? 0) + 1);
+        }
+      }
     }
   }
   const perAgentInfluence = {};
+  const perAgentStats = {};
   for (const [id, count] of appearances) {
-    perAgentInfluence[id] = (changedCounts.get(id) ?? 0) / count;
+    const flips = changedCounts.get(id) ?? 0;
+    const influence = flips / count;
+    perAgentInfluence[id] = influence;
+    const stats = {
+      appearances: count,
+      flips
+    };
+    if (options.groundTruth) {
+      const protective = protectiveCounts.get(id) ?? 0;
+      const corrective = correctiveCounts.get(id) ?? 0;
+      const net = (protective - corrective) / count;
+      stats.protectiveFlips = protective;
+      stats.correctiveFlips = corrective;
+      stats.netAccuracyImpact = net;
+      stats.role = net > 0.01 ? "Protective" : net < -0.01 ? "Harmful" : "Neutral";
+    }
+    perAgentStats[id] = stats;
   }
   const averageLoadBearingRatio = results.length === 0 ? 0 : results.reduce((sum, r) => sum + r.loadBearingRatio, 0) / results.length;
   const summary = {
     cases: cases.length,
     averageLoadBearingRatio,
-    perAgentInfluence
+    perAgentInfluence,
+    perAgentStats
   };
+  if (options.groundTruth && options.groundTruth.length === results.length) {
+    const correctCount = results.filter((r, idx) => equals(r.baseline, options.groundTruth[idx])).length;
+    summary.accuracy = {
+      baselineAccuracy: results.length === 0 ? 0 : correctCount / results.length,
+      correctBaselineCount: correctCount,
+      totalEvaluated: results.length
+    };
+  }
+  if (hasTelemetry) {
+    let pipelineTotalCost = 0;
+    let pipelineTotalTokens = 0;
+    for (const c of totalCostByAgent.values()) pipelineTotalCost += c;
+    for (const t of totalTokensByAgent.values()) pipelineTotalTokens += t;
+    const agentsRoi = {};
+    const recommendations = [];
+    for (const [id, count] of appearances) {
+      const agentCost = totalCostByAgent.get(id);
+      const agentTokens = totalTokensByAgent.get(id);
+      const agentLatency = totalLatencyByAgent.get(id);
+      const flips = changedCounts.get(id) ?? 0;
+      const influence = perAgentInfluence[id] ?? 0;
+      const roi = {};
+      if (agentCost !== void 0) {
+        roi.totalCost = agentCost;
+        if (flips > 0) roi.costPerVerdictFlip = agentCost / flips;
+        if (pipelineTotalCost > 0) roi.costShare = agentCost / pipelineTotalCost;
+      }
+      if (agentTokens !== void 0) {
+        roi.totalTokens = agentTokens;
+        if (flips > 0) roi.tokensPerVerdictFlip = agentTokens / flips;
+      }
+      if (agentLatency !== void 0) {
+        roi.averageLatencyMs = agentLatency / count;
+      }
+      if (roi.costShare !== void 0 && roi.costShare > 0) {
+        roi.efficiencyRatio = influence / roi.costShare;
+      }
+      agentsRoi[id] = roi;
+      if (roi.costShare !== void 0 && roi.costShare >= 0.2 && influence <= 0.05) {
+        recommendations.push({
+          agentId: id,
+          recommendation: "prune",
+          reason: `High compute cost (${(roi.costShare * 100).toFixed(1)}% of total cost) with negligible verdict impact (${(influence * 100).toFixed(1)}% influence).`
+        });
+      } else if (roi.efficiencyRatio !== void 0 && roi.efficiencyRatio < 0.25 && (roi.totalCost ?? 0) > 0.1) {
+        recommendations.push({
+          agentId: id,
+          recommendation: "downgrade_model",
+          reason: `Low efficiency ratio (${roi.efficiencyRatio.toFixed(2)}x). Consider replacing with a smaller/cheaper model.`
+        });
+      }
+    }
+    summary.roi = {
+      totalCost: pipelineTotalCost,
+      totalTokens: pipelineTotalTokens,
+      agents: agentsRoi,
+      recommendations
+    };
+  }
+  return summary;
+}
+function batchAblation(cases, decide, options = defaultEquals) {
+  const opts = typeof options === "function" ? { equals: options } : options;
+  const equals = opts.equals || defaultEquals;
+  const results = cases.map((findings) => runAblation(findings, decide, equals));
+  const summary = aggregateBatchResults(cases, results, opts);
+  return { results, summary };
+}
+async function batchAblationAsync(cases, decide, options = {}) {
+  const results = [];
+  for (const c of cases) {
+    results.push(await runAblationAsync(c, decide, options));
+  }
+  const summary = aggregateBatchResults(cases, results, options);
   return { results, summary };
 }
+function runBackwardElimination(findings, decide, equals = defaultEquals) {
+  const baseline = decide(findings.slice());
+  let currentFindings = findings.slice();
+  const eliminatedAgentIds = [];
+  const steps = [];
+  while (currentFindings.length > 1) {
+    let candidateIndexToRemove = -1;
+    let candidateVerdict;
+    for (let i = 0; i < currentFindings.length; i++) {
+      const withoutCandidate = currentFindings.slice(0, i).concat(currentFindings.slice(i + 1));
+      const v = decide(withoutCandidate);
+      if (equals(baseline, v)) {
+        candidateIndexToRemove = i;
+        candidateVerdict = v;
+        break;
+      }
+    }
+    if (candidateIndexToRemove === -1) {
+      return {
+        baseline,
+        minimalFindings: currentFindings,
+        minimalAgentIds: currentFindings.map((f) => f.agentId),
+        eliminatedAgentIds,
+        steps,
+        stoppedDueToVerdictFlip: true
+      };
+    }
+    const removed = currentFindings[candidateIndexToRemove];
+    currentFindings = currentFindings.slice(0, candidateIndexToRemove).concat(currentFindings.slice(candidateIndexToRemove + 1));
+    eliminatedAgentIds.push(removed.agentId);
+    steps.push({
+      step: steps.length + 1,
+      eliminatedAgentId: removed.agentId,
+      remainingAgentIds: currentFindings.map((f) => f.agentId),
+      verdict: candidateVerdict
+    });
+  }
+  return {
+    baseline,
+    minimalFindings: currentFindings,
+    minimalAgentIds: currentFindings.map((f) => f.agentId),
+    eliminatedAgentIds,
+    steps,
+    stoppedDueToVerdictFlip: false
+  };
+}
+async function runBackwardEliminationAsync(findings, decide, options = {}) {
+  const equals = options.equals || defaultEquals;
+  const samples = options.samples ?? 1;
+  async function evaluate(fs) {
+    if (samples <= 1) return await decide(fs.slice());
+    const sampleResults = [];
+    for (let i = 0; i < samples; i++) sampleResults.push(await decide(fs.slice()));
+    return options.aggregateSamples ? options.aggregateSamples(sampleResults) : majorityVote(sampleResults, equals);
+  }
+  const baseline = await evaluate(findings);
+  let currentFindings = findings.slice();
+  const eliminatedAgentIds = [];
+  const steps = [];
+  while (currentFindings.length > 1) {
+    let candidateIndexToRemove = -1;
+    let candidateVerdict;
+    for (let i = 0; i < currentFindings.length; i++) {
+      const withoutCandidate = currentFindings.slice(0, i).concat(currentFindings.slice(i + 1));
+      const v = await evaluate(withoutCandidate);
+      if (equals(baseline, v)) {
+        candidateIndexToRemove = i;
+        candidateVerdict = v;
+        break;
+      }
+    }
+    if (candidateIndexToRemove === -1) {
+      return {
+        baseline,
+        minimalFindings: currentFindings,
+        minimalAgentIds: currentFindings.map((f) => f.agentId),
+        eliminatedAgentIds,
+        steps,
+        stoppedDueToVerdictFlip: true
+      };
+    }
+    const removed = currentFindings[candidateIndexToRemove];
+    currentFindings = currentFindings.slice(0, candidateIndexToRemove).concat(currentFindings.slice(candidateIndexToRemove + 1));
+    eliminatedAgentIds.push(removed.agentId);
+    steps.push({
+      step: steps.length + 1,
+      eliminatedAgentId: removed.agentId,
+      remainingAgentIds: currentFindings.map((f) => f.agentId),
+      verdict: candidateVerdict
+    });
+  }
+  return {
+    baseline,
+    minimalFindings: currentFindings,
+    minimalAgentIds: currentFindings.map((f) => f.agentId),
+    eliminatedAgentIds,
+    steps,
+    stoppedDueToVerdictFlip: false
+  };
+}
+function runPairwiseAblation(findings, decide, equals = defaultEquals) {
+  const singleResult = runAblation(findings, decide, equals);
+  const baseline = singleResult.baseline;
+  const singleChangedMap = /* @__PURE__ */ new Map();
+  for (const p of singleResult.perAgent) {
+    singleChangedMap.set(p.removedAgentId, p.changed);
+  }
+  const pairs = [];
+  for (let i = 0; i < findings.length; i++) {
+    for (let j = i + 1; j < findings.length; j++) {
+      const agentI = findings[i];
+      const agentJ = findings[j];
+      const withoutPair = findings.filter((_, idx) => idx !== i && idx !== j);
+      const verdictWithout = decide(withoutPair);
+      const changed = !equals(baseline, verdictWithout);
+      const singleIChanged = singleChangedMap.get(agentI.agentId) ?? false;
+      const singleJChanged = singleChangedMap.get(agentJ.agentId) ?? false;
+      const isInteraction = changed && !singleIChanged && !singleJChanged;
+      pairs.push({
+        pair: [agentI.agentId, agentJ.agentId],
+        verdictWithout,
+        changed,
+        isInteraction
+      });
+    }
+  }
+  const interactionCount = pairs.filter((p) => p.isInteraction).length;
+  return {
+    baseline,
+    pairs,
+    interactionCount
+  };
+}
 export {
+  aggregateBatchResults,
   batchAblation,
+  batchAblationAsync,
+  formatAsciiTable,
+  formatMarkdownReport,
+  fromAISDKSteps,
+  fromAutoGenMessages,
+  fromCrewAITasks,
   fromLangGraphMessages,
   fromRecords,
-  runAblation
+  majorityVote,
+  runAblation,
+  runAblationAsync,
+  runBackwardElimination,
+  runBackwardEliminationAsync,
+  runPairwiseAblation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-ablation",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Leave-one-out ablation testing for multi-agent decision systems — find out which agents' findings actually change the outcome.",
   "type": "module",
   "main": "./dist/index.cjs",