@criterionx/devtools 0.3.1

package/README.md

@@ -0,0 +1,187 @@
+# @criterionx/devtools
+
+Development tools for debugging and visualizing Criterion decision traces.
+
+## Installation
+
+```bash
+npm install @criterionx/devtools
+# or
+pnpm add @criterionx/devtools
+```
+
+## Features
+
+- **Trace Collector** - Capture and analyze decision evaluations
+- **HTML Report** - Visual trace viewer with rule evaluation details
+- **Export** - JSON, HTML, and Markdown export formats
+- **Console Formatting** - Pretty-print traces for debugging
+- **Statistics** - Summary analytics for collected traces
+
+## Usage
+
+### Collecting Traces
+
+```typescript
+import { createCollector } from "@criterionx/devtools";
+import { riskDecision } from "./decisions";
+
+const collector = createCollector({
+  maxTraces: 1000, // Maximum traces to keep
+  autoLog: true,   // Log to console automatically
+});
+
+// Use collector.run() instead of engine.run()
+const result = collector.run(
+  riskDecision,
+  { amount: 50000, country: "US" },
+  { profile: defaultProfile }
+);
+
+// Get the last trace
+const trace = collector.getLastTrace();
+console.log(trace?.result.status); // "OK"
+console.log(trace?.durationMs);    // 0.42
+```
+
+### Generating HTML Reports
+
+```typescript
+import { createCollector, generateHtmlReport } from "@criterionx/devtools";
+import fs from "fs";
+
+const collector = createCollector();
+
+// Run some decisions
+collector.run(riskDecision, input1, { profile });
+collector.run(riskDecision, input2, { profile });
+collector.run(riskDecision, input3, { profile });
+
+// Generate HTML report
+const html = generateHtmlReport(
+  collector.getTraces(),
+  collector.getSummary(),
+  {
+    title: "Risk Decision Traces",
+    darkMode: true,
+  }
+);
+
+fs.writeFileSync("traces.html", html);
+```
+
+### Console Output
+
+```typescript
+import { createCollector, formatTraceForConsole } from "@criterionx/devtools";
+
+const collector = createCollector();
+collector.run(riskDecision, { amount: 100, country: "US" }, { profile });
+
+const trace = collector.getLastTrace()!;
+console.log(formatTraceForConsole(trace));
+
+// Output:
+// ──────────────────────────────────────────────────
+// Decision: transaction-risk v1.0.0
+// Status: OK
+// Duration: 0.42ms
+// Time: 2024-01-15T10:30:00.000Z
+//
+// Rule Evaluation:
+//   ✗ blocked-country
+//   ✗ high-amount
+//   ✓ default — Default low risk
+//
+// Result: Default low risk
+// ──────────────────────────────────────────────────
+```
+
+### Exporting Traces
+
+```typescript
+import { createCollector, exportToJson, exportTrace } from "@criterionx/devtools";
+
+const collector = createCollector();
+// ... run decisions ...
+
+// Export all traces as JSON
+const json = exportToJson(collector.getTraces(), {
+  pretty: true,
+  includeData: true, // Include input/output data
+});
+
+// Export single trace as markdown
+const trace = collector.getLastTrace()!;
+const markdown = exportTrace(trace, "markdown");
+```
+
+### Statistics
+
+```typescript
+const collector = createCollector();
+// ... run multiple decisions ...
+
+const summary = collector.getSummary();
+
+console.log(summary.totalTraces);     // 150
+console.log(summary.avgDurationMs);   // 0.38
+console.log(summary.byStatus);        // { OK: 145, NO_MATCH: 5 }
+console.log(summary.byRule);          // { "high-risk": 50, "default": 95, ... }
+console.log(summary.byDecision);      // { "transaction-risk": 100, ... }
+```
+
+## API Reference
+
+### `createCollector(options?)`
+
+Create a new trace collector.
+
+**Options:**
+- `maxTraces` - Maximum traces to keep (default: 1000)
+- `autoLog` - Log traces to console (default: false)
+
+**Methods:**
+- `run(decision, input, options, registry?)` - Run decision and collect trace
+- `getTraces()` - Get all collected traces
+- `getTracesForDecision(id)` - Filter traces by decision ID
+- `getLastTrace()` - Get most recent trace
+- `getSummary()` - Get statistics summary
+- `clear()` - Clear all traces
+- `count` - Number of traces
+
+### `generateHtmlReport(traces, summary, options?)`
+
+Generate an HTML report.
+
+**Options:**
+- `title` - Report title (default: "Criterion Trace Viewer")
+- `darkMode` - Use dark theme (default: false)
+
+### `formatTraceForConsole(trace)`
+
+Format a trace for console output.
+
+### `exportToJson(traces, options?)`
+
+Export traces as JSON.
+
+**Options:**
+- `pretty` - Pretty print (default: true)
+- `includeData` - Include input/output (default: true)
+
+### `exportToHtml(traces, summary, options?)`
+
+Export traces as HTML (same as `generateHtmlReport`).
+
+### `exportTrace(trace, format)`
+
+Export single trace as JSON or Markdown.
+
+### `createShareableUrl(traces, summary, options?)`
+
+Create a data URI for sharing (base64 encoded HTML).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,141 @@
+import { Result, Decision, RunOptions, ProfileRegistry } from '@criterionx/core';
+
+/**
+ * A recorded trace of a decision evaluation
+ */
+interface Trace<TInput = unknown, TOutput = unknown, TProfile = unknown> {
+    id: string;
+    timestamp: string;
+    decisionId: string;
+    decisionVersion: string;
+    input: TInput;
+    profile: TProfile;
+    profileId?: string;
+    result: Result<TOutput>;
+    durationMs: number;
+}
+/**
+ * Options for the trace collector
+ */
+interface CollectorOptions {
+    /** Maximum number of traces to keep in memory */
+    maxTraces?: number;
+    /** Auto-flush traces to console */
+    autoLog?: boolean;
+}
+/**
+ * Options for exporting traces
+ */
+interface ExportOptions {
+    /** Format to export */
+    format: "json" | "html";
+    /** Include input/output data */
+    includeData?: boolean;
+    /** Pretty print JSON */
+    pretty?: boolean;
+}
+/**
+ * Summary statistics for collected traces
+ */
+interface TraceSummary {
+    totalTraces: number;
+    byDecision: Record<string, number>;
+    byStatus: Record<string, number>;
+    byRule: Record<string, number>;
+    avgDurationMs: number;
+}
+/**
+ * Options for the HTML viewer
+ */
+interface ViewerOptions {
+    /** Title for the HTML report */
+    title?: string;
+    /** Include inline styles */
+    inlineStyles?: boolean;
+    /** Dark mode */
+    darkMode?: boolean;
+}
+
+/**
+ * Trace Collector
+ *
+ * Wraps the Criterion engine to collect and analyze decision traces.
+ */
+declare class TraceCollector {
+    private traces;
+    private readonly maxTraces;
+    private readonly autoLog;
+    private readonly engine;
+    constructor(options?: CollectorOptions);
+    /**
+     * Run a decision and collect the trace
+     */
+    run<TInput, TOutput, TProfile>(decision: Decision<TInput, TOutput, TProfile>, input: TInput, options: RunOptions<TProfile>, registry?: ProfileRegistry<TProfile>): Result<TOutput>;
+    /**
+     * Add a trace to the collection
+     */
+    private addTrace;
+    /**
+     * Log a trace to console
+     */
+    private logTrace;
+    /**
+     * Get all collected traces
+     */
+    getTraces(): Trace[];
+    /**
+     * Get traces for a specific decision
+     */
+    getTracesForDecision(decisionId: string): Trace[];
+    /**
+     * Get the most recent trace
+     */
+    getLastTrace(): Trace | undefined;
+    /**
+     * Get summary statistics
+     */
+    getSummary(): TraceSummary;
+    /**
+     * Clear all traces
+     */
+    clear(): void;
+    /**
+     * Get trace count
+     */
+    get count(): number;
+}
+/**
+ * Create a new trace collector
+ */
+declare function createCollector(options?: CollectorOptions): TraceCollector;
+
+/**
+ * Generate a complete HTML report for traces
+ */
+declare function generateHtmlReport(traces: Trace[], summary: TraceSummary, options?: ViewerOptions): string;
+/**
+ * Format a trace for console output
+ */
+declare function formatTraceForConsole(trace: Trace): string;
+
+/**
+ * Export traces to JSON format
+ */
+declare function exportToJson(traces: Trace[], options?: {
+    pretty?: boolean;
+    includeData?: boolean;
+}): string;
+/**
+ * Export traces to HTML format
+ */
+declare function exportToHtml(traces: Trace[], summary: TraceSummary, options?: ViewerOptions): string;
+/**
+ * Export a single trace for debugging
+ */
+declare function exportTrace(trace: Trace, format?: "json" | "markdown"): string;
+/**
+ * Create a shareable report URL (data URI)
+ */
+declare function createShareableUrl(traces: Trace[], summary: TraceSummary, options?: ViewerOptions): string;
+
+export { type CollectorOptions, type ExportOptions, type Trace, TraceCollector, type TraceSummary, type ViewerOptions, createCollector, createShareableUrl, exportToHtml, exportToJson, exportTrace, formatTraceForConsole, generateHtmlReport };

package/dist/index.js

@@ -0,0 +1,415 @@
+// src/collector.ts
+import {
+  Engine
+} from "@criterionx/core";
+function generateId() {
+  return `trace_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+var TraceCollector = class {
+  traces = [];
+  maxTraces;
+  autoLog;
+  engine;
+  constructor(options = {}) {
+    this.maxTraces = options.maxTraces ?? 1e3;
+    this.autoLog = options.autoLog ?? false;
+    this.engine = new Engine();
+  }
+  /**
+   * Run a decision and collect the trace
+   */
+  run(decision, input, options, registry) {
+    const startTime = performance.now();
+    const result = this.engine.run(decision, input, options, registry);
+    const endTime = performance.now();
+    const durationMs = endTime - startTime;
+    const trace = {
+      id: generateId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      decisionId: decision.id,
+      decisionVersion: decision.version,
+      input,
+      profile: typeof options.profile === "string" ? registry?.get(options.profile) : options.profile,
+      profileId: typeof options.profile === "string" ? options.profile : void 0,
+      result,
+      durationMs
+    };
+    this.addTrace(trace);
+    if (this.autoLog) {
+      this.logTrace(trace);
+    }
+    return result;
+  }
+  /**
+   * Add a trace to the collection
+   */
+  addTrace(trace) {
+    this.traces.push(trace);
+    if (this.traces.length > this.maxTraces) {
+      this.traces = this.traces.slice(-this.maxTraces);
+    }
+  }
+  /**
+   * Log a trace to console
+   */
+  logTrace(trace) {
+    const status = trace.result.status;
+    const rule = trace.result.meta.matchedRule ?? "none";
+    const duration = trace.durationMs.toFixed(2);
+    console.log(
+      `[Criterion] ${trace.decisionId} | ${status} | rule: ${rule} | ${duration}ms`
+    );
+  }
+  /**
+   * Get all collected traces
+   */
+  getTraces() {
+    return [...this.traces];
+  }
+  /**
+   * Get traces for a specific decision
+   */
+  getTracesForDecision(decisionId) {
+    return this.traces.filter((t) => t.decisionId === decisionId);
+  }
+  /**
+   * Get the most recent trace
+   */
+  getLastTrace() {
+    return this.traces[this.traces.length - 1];
+  }
+  /**
+   * Get summary statistics
+   */
+  getSummary() {
+    const byDecision = {};
+    const byStatus = {};
+    const byRule = {};
+    let totalDuration = 0;
+    for (const trace of this.traces) {
+      byDecision[trace.decisionId] = (byDecision[trace.decisionId] ?? 0) + 1;
+      byStatus[trace.result.status] = (byStatus[trace.result.status] ?? 0) + 1;
+      const rule = trace.result.meta.matchedRule ?? "NO_MATCH";
+      byRule[rule] = (byRule[rule] ?? 0) + 1;
+      totalDuration += trace.durationMs;
+    }
+    return {
+      totalTraces: this.traces.length,
+      byDecision,
+      byStatus,
+      byRule,
+      avgDurationMs: this.traces.length > 0 ? totalDuration / this.traces.length : 0
+    };
+  }
+  /**
+   * Clear all traces
+   */
+  clear() {
+    this.traces = [];
+  }
+  /**
+   * Get trace count
+   */
+  get count() {
+    return this.traces.length;
+  }
+};
+function createCollector(options) {
+  return new TraceCollector(options);
+}
+
+// src/viewer.ts
+function generateStyles(darkMode) {
+  const bg = darkMode ? "#1a1a2e" : "#ffffff";
+  const bgCard = darkMode ? "#16213e" : "#f8f9fa";
+  const text = darkMode ? "#eaeaea" : "#212529";
+  const textMuted = darkMode ? "#a0a0a0" : "#6c757d";
+  const border = darkMode ? "#0f3460" : "#dee2e6";
+  const success = "#28a745";
+  const danger = "#dc3545";
+  const warning = "#ffc107";
+  return `
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: ${bg};
+      color: ${text};
+      line-height: 1.6;
+      padding: 2rem;
+    }
+    .container { max-width: 1200px; margin: 0 auto; }
+    h1 { margin-bottom: 1.5rem; font-size: 1.75rem; }
+    h2 { margin: 1.5rem 0 1rem; font-size: 1.25rem; color: ${textMuted}; }
+    .summary {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1rem;
+      margin-bottom: 2rem;
+    }
+    .stat {
+      background: ${bgCard};
+      border: 1px solid ${border};
+      border-radius: 8px;
+      padding: 1rem;
+    }
+    .stat-value { font-size: 2rem; font-weight: bold; }
+    .stat-label { color: ${textMuted}; font-size: 0.875rem; }
+    .trace {
+      background: ${bgCard};
+      border: 1px solid ${border};
+      border-radius: 8px;
+      margin-bottom: 1rem;
+      overflow: hidden;
+    }
+    .trace-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 1rem;
+      border-bottom: 1px solid ${border};
+      cursor: pointer;
+    }
+    .trace-header:hover { background: ${darkMode ? "#1f2b4a" : "#f1f3f4"}; }
+    .trace-title { font-weight: 600; }
+    .trace-meta { display: flex; gap: 1rem; font-size: 0.875rem; color: ${textMuted}; }
+    .badge {
+      display: inline-block;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+      font-size: 0.75rem;
+      font-weight: 600;
+    }
+    .badge-ok { background: ${success}; color: white; }
+    .badge-no-match { background: ${warning}; color: black; }
+    .badge-invalid { background: ${danger}; color: white; }
+    .trace-body { padding: 1rem; display: none; }
+    .trace.open .trace-body { display: block; }
+    .trace-section { margin-bottom: 1rem; }
+    .trace-section-title { font-weight: 600; margin-bottom: 0.5rem; font-size: 0.875rem; }
+    .rules-list { list-style: none; }
+    .rule {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem;
+      border-radius: 4px;
+      margin-bottom: 0.25rem;
+    }
+    .rule-matched { background: ${darkMode ? "#1a3a2a" : "#d4edda"}; }
+    .rule-icon { font-size: 1rem; }
+    .rule-id { font-weight: 500; }
+    .rule-explain { color: ${textMuted}; font-size: 0.875rem; }
+    pre {
+      background: ${darkMode ? "#0d1117" : "#f6f8fa"};
+      border: 1px solid ${border};
+      border-radius: 4px;
+      padding: 1rem;
+      overflow-x: auto;
+      font-size: 0.875rem;
+    }
+    code { font-family: 'SF Mono', Monaco, Consolas, monospace; }
+  `;
+}
+function renderTrace(trace, index) {
+  const statusClass = trace.result.status === "OK" ? "badge-ok" : trace.result.status === "NO_MATCH" ? "badge-no-match" : "badge-invalid";
+  const rules = trace.result.meta.evaluatedRules.map(
+    (rule) => `
+      <li class="rule ${rule.matched ? "rule-matched" : ""}">
+        <span class="rule-icon">${rule.matched ? "\u2713" : "\u2717"}</span>
+        <span class="rule-id">${rule.ruleId}</span>
+        ${rule.explanation ? `<span class="rule-explain">\u2014 ${rule.explanation}</span>` : ""}
+      </li>
+    `
+  ).join("");
+  return `
+    <div class="trace" id="trace-${index}">
+      <div class="trace-header" onclick="toggleTrace(${index})">
+        <div>
+          <span class="trace-title">${trace.decisionId}</span>
+          <span class="badge ${statusClass}">${trace.result.status}</span>
+        </div>
+        <div class="trace-meta">
+          <span>${trace.result.meta.matchedRule ?? "No match"}</span>
+          <span>${trace.durationMs.toFixed(2)}ms</span>
+          <span>${new Date(trace.timestamp).toLocaleTimeString()}</span>
+        </div>
+      </div>
+      <div class="trace-body">
+        <div class="trace-section">
+          <div class="trace-section-title">Rule Evaluation</div>
+          <ul class="rules-list">${rules}</ul>
+        </div>
+        <div class="trace-section">
+          <div class="trace-section-title">Input</div>
+          <pre><code>${JSON.stringify(trace.input, null, 2)}</code></pre>
+        </div>
+        ${trace.result.data ? `
+        <div class="trace-section">
+          <div class="trace-section-title">Output</div>
+          <pre><code>${JSON.stringify(trace.result.data, null, 2)}</code></pre>
+        </div>
+        ` : ""}
+        <div class="trace-section">
+          <div class="trace-section-title">Explanation</div>
+          <p>${trace.result.meta.explanation}</p>
+        </div>
+      </div>
+    </div>
+  `;
+}
+function renderSummary(summary) {
+  return `
+    <div class="summary">
+      <div class="stat">
+        <div class="stat-value">${summary.totalTraces}</div>
+        <div class="stat-label">Total Traces</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${summary.avgDurationMs.toFixed(2)}ms</div>
+        <div class="stat-label">Avg Duration</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${summary.byStatus["OK"] ?? 0}</div>
+        <div class="stat-label">Successful</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${(summary.byStatus["NO_MATCH"] ?? 0) + (summary.byStatus["INVALID_INPUT"] ?? 0) + (summary.byStatus["INVALID_OUTPUT"] ?? 0)}</div>
+        <div class="stat-label">Failed/No Match</div>
+      </div>
+    </div>
+  `;
+}
+function generateHtmlReport(traces, summary, options = {}) {
+  const title = options.title ?? "Criterion Trace Viewer";
+  const darkMode = options.darkMode ?? false;
+  const tracesHtml = traces.slice().reverse().map((t, i) => renderTrace(t, i)).join("");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>${generateStyles(darkMode)}</style>
+</head>
+<body>
+  <div class="container">
+    <h1>${title}</h1>
+
+    <h2>Summary</h2>
+    ${renderSummary(summary)}
+
+    <h2>Traces (${traces.length})</h2>
+    ${tracesHtml || "<p>No traces recorded yet.</p>"}
+  </div>
+
+  <script>
+    function toggleTrace(index) {
+      const trace = document.getElementById('trace-' + index);
+      trace.classList.toggle('open');
+    }
+  </script>
+</body>
+</html>`;
+}
+function formatTraceForConsole(trace) {
+  const lines = [];
+  const hr = "\u2500".repeat(50);
+  lines.push(hr);
+  lines.push(`Decision: ${trace.decisionId} v${trace.decisionVersion}`);
+  lines.push(`Status: ${trace.result.status}`);
+  lines.push(`Duration: ${trace.durationMs.toFixed(2)}ms`);
+  lines.push(`Time: ${trace.timestamp}`);
+  lines.push("");
+  lines.push("Rule Evaluation:");
+  for (const rule of trace.result.meta.evaluatedRules) {
+    const icon = rule.matched ? "\u2713" : "\u2717";
+    const explain = rule.explanation ? ` \u2014 ${rule.explanation}` : "";
+    lines.push(`  ${icon} ${rule.ruleId}${explain}`);
+  }
+  lines.push("");
+  lines.push(`Result: ${trace.result.meta.explanation}`);
+  lines.push(hr);
+  return lines.join("\n");
+}
+
+// src/export.ts
+function exportToJson(traces, options = {}) {
+  const { pretty = true, includeData = true } = options;
+  const exportData = traces.map((trace) => {
+    if (!includeData) {
+      return {
+        id: trace.id,
+        timestamp: trace.timestamp,
+        decisionId: trace.decisionId,
+        decisionVersion: trace.decisionVersion,
+        status: trace.result.status,
+        matchedRule: trace.result.meta.matchedRule,
+        durationMs: trace.durationMs
+      };
+    }
+    return trace;
+  });
+  return pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
+}
+function exportToHtml(traces, summary, options = {}) {
+  return generateHtmlReport(traces, summary, options);
+}
+function exportTrace(trace, format = "json") {
+  if (format === "markdown") {
+    return formatTraceAsMarkdown(trace);
+  }
+  return JSON.stringify(trace, null, 2);
+}
+function formatTraceAsMarkdown(trace) {
+  const lines = [];
+  lines.push(`# Trace: ${trace.decisionId}`);
+  lines.push("");
+  lines.push(`- **Version:** ${trace.decisionVersion}`);
+  lines.push(`- **Status:** ${trace.result.status}`);
+  lines.push(`- **Duration:** ${trace.durationMs.toFixed(2)}ms`);
+  lines.push(`- **Timestamp:** ${trace.timestamp}`);
+  lines.push("");
+  lines.push("## Rule Evaluation");
+  lines.push("");
+  lines.push("| Rule | Matched | Explanation |");
+  lines.push("|------|---------|-------------|");
+  for (const rule of trace.result.meta.evaluatedRules) {
+    const matched = rule.matched ? "Yes" : "No";
+    const explain = rule.explanation ?? "-";
+    lines.push(`| ${rule.ruleId} | ${matched} | ${explain} |`);
+  }
+  lines.push("");
+  lines.push("## Input");
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify(trace.input, null, 2));
+  lines.push("```");
+  lines.push("");
+  if (trace.result.data) {
+    lines.push("## Output");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(trace.result.data, null, 2));
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Explanation");
+  lines.push("");
+  lines.push(trace.result.meta.explanation);
+  return lines.join("\n");
+}
+function createShareableUrl(traces, summary, options = {}) {
+  const html = generateHtmlReport(traces, summary, options);
+  const encoded = Buffer.from(html).toString("base64");
+  return `data:text/html;base64,${encoded}`;
+}
+export {
+  TraceCollector,
+  createCollector,
+  createShareableUrl,
+  exportToHtml,
+  exportToJson,
+  exportTrace,
+  formatTraceForConsole,
+  generateHtmlReport
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@criterionx/devtools",
+  "version": "0.3.1",
+  "description": "Development tools for debugging Criterion decisions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "criterion",
+    "devtools",
+    "debugging",
+    "decision-engine",
+    "trace-viewer"
+  ],
+  "author": {
+    "name": "Tomas Maritano",
+    "url": "https://github.com/tomymaritano"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tomymaritano/criterionx.git",
+    "directory": "packages/devtools"
+  },
+  "bugs": {
+    "url": "https://github.com/tomymaritano/criterionx/issues"
+  },
+  "homepage": "https://github.com/tomymaritano/criterionx#readme",
+  "dependencies": {
+    "@criterionx/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.0",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}