@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/families/agent-research-harness-ts/files/tests/research-runner.test.ts

@@ -0,0 +1,422 @@
+/**
+ * research-harness tests.
+ *
+ * These exercise the screener + validator + runner directly with a
+ * synthetic ScenarioRunner so we don't depend on a live LLM or eval
+ * harness. The shape under test:
+ *
+ *   1. queue load — validates the JSON schema gate before any run.
+ *   2. proposer output shape — verifies parseHypotheses + verifier gates.
+ *   3. screener ranks correctly — descending by delta, floor enforced.
+ *   4. validator gates correctly — promote/reject/inconclusive verdicts.
+ *
+ * Each test names a concrete regression it would catch.
+ */
+
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import { propose } from '../src/research/proposer.js'
+import { loadQueue, runScreen, runSweep } from '../src/research/runner.js'
+import { screen } from '../src/research/screener.js'
+import { validate } from '../src/research/validator.js'
+import type { Hypothesis, ScenarioRunner, ScenarioSample } from '../src/research/types.js'
+
+function tmpFile(name: string, content: string): string {
+  const dir = mkdtempSync(join(tmpdir(), 'research-harness-'))
+  const path = join(dir, name)
+  writeFileSync(path, content, 'utf8')
+  return path
+}
+
+function tmpDir(): string {
+  return mkdtempSync(join(tmpdir(), 'research-harness-results-'))
+}
+
+interface FakeRunnerInput {
+  scenarioIds: readonly string[]
+  /** Map hypothesis id → score per scenario. `null` means baseline. */
+  scores: Map<string | null, Map<string, number>>
+  costPerCall?: number
+  wallPerCall?: number
+}
+
+function fakeRunner(input: FakeRunnerInput): ScenarioRunner {
+  return {
+    scenarioIds: input.scenarioIds,
+    runTrial: async ({ hypothesis, scenarioId }): Promise<ScenarioSample> => {
+      const key = hypothesis?.id ?? null
+      const map = input.scores.get(key)
+      const score = map?.get(scenarioId) ?? 0
+      return {
+        scenarioId,
+        score,
+        costUsd: input.costPerCall ?? 0.01,
+        wallSeconds: input.wallPerCall ?? 1,
+        ok: score > 0,
+      }
+    },
+  }
+}
+
+test('queue load — rejects malformed queue', () => {
+  const bad = tmpFile('bad-queue.json', JSON.stringify({ wrongKey: [] }))
+  assert.throws(() => loadQueue(bad), /missing 'hypotheses' array/)
+
+  const good = tmpFile(
+    'good-queue.json',
+    JSON.stringify({
+      hypotheses: [
+        {
+          id: 'h-1',
+          name: 'one',
+          rationale: 'because',
+          category: 'bug-fix',
+          expected_impact: 'pass: +5pp',
+          priority: 1,
+          treatment: { kind: 'noop' },
+        },
+      ],
+    }),
+  )
+  const queue = loadQueue(good)
+  assert.equal(queue.hypotheses.length, 1)
+  assert.equal(queue.hypotheses[0]?.id, 'h-1')
+})
+
+test('proposer — verifier rejects malformed LLM output and reports issues', async () => {
+  const out = await propose({
+    goal: 'reduce judge-rubric failures on tool-use scenarios',
+    count: 4,
+    callJson: async () => ({ hypotheses: 'not-an-array' }),
+    maxShots: 2,
+  })
+  assert.equal(out.hypotheses.length, 0)
+  assert.equal(out.report.finalVerification.pass, false)
+  // Reviewer should have run and asked for a revision.
+  assert.ok(out.report.shots.length >= 1)
+})
+
+test('proposer — verifier accepts well-shaped output covering required categories', async () => {
+  const draft: Hypothesis[] = [
+    {
+      id: 'fix-tool-loop',
+      name: 'Fix tool-call loop',
+      rationale: 'Trace shows infinite loop on rate-limit; needs backoff.',
+      category: 'bug-fix',
+      expected_impact: 'pass rate: +3pp',
+      priority: 1,
+      treatment: { kind: 'patch', sha: 'deadbeef' },
+    },
+    {
+      id: 'parallel-tools',
+      name: 'Parallel independent tools',
+      rationale: 'Independent tool calls serialised; batch them.',
+      category: 'architectural',
+      expected_impact: 'wallSeconds: -30%',
+      priority: 1,
+      treatment: { kind: 'system-prompt-delta', append: '...' },
+    },
+    {
+      id: 'cheaper-model-cot',
+      name: 'Cheaper model on CoT',
+      rationale: 'CoT scenarios show cost dominated by reasoning tokens.',
+      category: 'efficiency',
+      expected_impact: 'cost: -25%',
+      priority: 2,
+      treatment: { kind: 'config', delta: { reasoningModel: 'haiku' } },
+    },
+  ]
+  const out = await propose({
+    goal: 'broad improvement sweep',
+    count: 3,
+    callJson: async () => ({ hypotheses: draft }),
+    maxShots: 1,
+  })
+  assert.equal(out.hypotheses.length, 3)
+  assert.equal(out.report.finalVerification.pass, true)
+  const ids = out.hypotheses.map((h) => h.id).sort()
+  assert.deepEqual(ids, ['cheaper-model-cot', 'fix-tool-loop', 'parallel-tools'])
+})
+
+test('screener — ranks descending by delta and enforces floor', async () => {
+  const scenarioIds = ['s1', 's2', 's3']
+  const baselineMap = new Map([
+    ['s1', 0.5],
+    ['s2', 0.5],
+    ['s3', 0.5],
+  ])
+  const winnerMap = new Map([
+    ['s1', 0.8],
+    ['s2', 0.7],
+    ['s3', 0.6],
+  ])
+  const looserMap = new Map([
+    ['s1', 0.55],
+    ['s2', 0.55],
+    ['s3', 0.55],
+  ])
+  const wreckMap = new Map([
+    ['s1', 0.1],
+    ['s2', 0.2],
+    ['s3', 0.1],
+  ])
+  const runner = fakeRunner({
+    scenarioIds,
+    scores: new Map<string | null, Map<string, number>>([
+      [null, baselineMap],
+      ['winner', winnerMap],
+      ['looser', looserMap],
+      ['wreck', wreckMap],
+    ]),
+  })
+  const hypotheses: Hypothesis[] = [
+    {
+      id: 'wreck',
+      name: 'wreck',
+      rationale: 'r',
+      category: 'parameter-tuning',
+      expected_impact: 'x',
+      priority: 3,
+      treatment: {},
+    },
+    {
+      id: 'looser',
+      name: 'looser',
+      rationale: 'r',
+      category: 'efficiency',
+      expected_impact: 'x',
+      priority: 2,
+      treatment: {},
+    },
+    {
+      id: 'winner',
+      name: 'winner',
+      rationale: 'r',
+      category: 'architectural',
+      expected_impact: 'x',
+      priority: 1,
+      treatment: {},
+    },
+  ]
+  const report = await screen({
+    hypotheses,
+    runner,
+    floorTolerance: 0.02,
+    now: () => new Date('2026-01-01T00:00:00Z'),
+  })
+  // Sorted descending by delta: winner > looser > wreck.
+  assert.deepEqual(
+    report.ranked.map((r) => r.hypothesisId),
+    ['winner', 'looser', 'wreck'],
+  )
+  // Floor: winner + looser pass; wreck rejected.
+  assert.deepEqual(report.passedFloor, ['winner', 'looser'])
+  const wreckResult = report.ranked.find((r) => r.hypothesisId === 'wreck')
+  assert.equal(wreckResult?.verdict, 'reject')
+})
+
+test('screener — refuses to run with <3 scenarios (catches anti-overfitting violation)', async () => {
+  const runner = fakeRunner({
+    scenarioIds: ['only-one'],
+    scores: new Map(),
+  })
+  await assert.rejects(
+    () =>
+      screen({
+        hypotheses: [],
+        runner,
+      }),
+    /requires >= 3 scenarios/,
+  )
+})
+
+test('validator — promotes when CI lower bound > 0', async () => {
+  // Big consistent positive delta → CI strictly > 0.
+  const scenarioIds = ['s1', 's2', 's3', 's4']
+  const baseMap = new Map(scenarioIds.map((id, i) => [id, 0.4 + i * 0.01]))
+  const winMap = new Map(scenarioIds.map((id, i) => [id, 0.85 + i * 0.01]))
+  const runner = fakeRunner({
+    scenarioIds,
+    scores: new Map<string | null, Map<string, number>>([
+      [null, baseMap],
+      ['big-win', winMap],
+    ]),
+  })
+  const report = await validate({
+    hypotheses: [
+      {
+        id: 'big-win',
+        name: 'big',
+        rationale: 'r',
+        category: 'architectural',
+        expected_impact: 'x',
+        priority: 1,
+        treatment: {},
+      },
+    ],
+    runner,
+    reps: 3,
+    iterations: 500,
+    seed: 42,
+  })
+  const result = report.results[0]
+  assert.ok(result, 'expected a result')
+  assert.equal(result.verdict, 'promote')
+  assert.ok(result.ci95 !== null, 'validator must populate ci95 (reps>=2)')
+  assert.ok(result.ci95.lower > 0, `expected ciLower > 0, got ${result.ci95.lower}`)
+  assert.equal(report.paretoFrontier.length, 1)
+})
+
+test('validator — rejects when CI upper bound < 0', async () => {
+  const scenarioIds = ['s1', 's2', 's3', 's4']
+  const baseMap = new Map(scenarioIds.map((id, i) => [id, 0.85 + i * 0.01]))
+  const loseMap = new Map(scenarioIds.map((id, i) => [id, 0.4 + i * 0.01]))
+  const runner = fakeRunner({
+    scenarioIds,
+    scores: new Map<string | null, Map<string, number>>([
+      [null, baseMap],
+      ['big-loss', loseMap],
+    ]),
+  })
+  const report = await validate({
+    hypotheses: [
+      {
+        id: 'big-loss',
+        name: 'lose',
+        rationale: 'r',
+        category: 'parameter-tuning',
+        expected_impact: 'x',
+        priority: 3,
+        treatment: {},
+      },
+    ],
+    runner,
+    reps: 3,
+    iterations: 500,
+    seed: 42,
+  })
+  const result = report.results[0]
+  assert.ok(result, 'expected a result')
+  assert.equal(result.verdict, 'reject')
+  assert.ok(result.ci95 !== null, 'validator must populate ci95 (reps>=2)')
+  assert.ok(result.ci95.upper < 0, `expected ciUpper < 0, got ${result.ci95.upper}`)
+})
+
+test('validator — refuses empty candidate set in runner.runValidate', async () => {
+  const queuePath = tmpFile(
+    'queue.json',
+    JSON.stringify({
+      hypotheses: [
+        {
+          id: 'real-one',
+          name: 'real',
+          rationale: 'r',
+          category: 'bug-fix',
+          expected_impact: 'x',
+          priority: 1,
+          treatment: {},
+        },
+      ],
+    }),
+  )
+  const { runValidate } = await import('../src/research/runner.js')
+  const runner = fakeRunner({
+    scenarioIds: ['s1', 's2', 's3'],
+    scores: new Map(),
+  })
+  await assert.rejects(
+    () =>
+      runValidate({
+        queuePath,
+        resultsDir: tmpDir(),
+        runner,
+        candidateIds: ['nonexistent'],
+      }),
+    /empty candidate set/,
+  )
+})
+
+test('runSweep — writes scorecard and skips validate when no candidates pass', async () => {
+  const scenarioIds = ['s1', 's2', 's3']
+  // All hypotheses worse than baseline → none pass screener floor.
+  const baseMap = new Map(scenarioIds.map((id) => [id, 0.9]))
+  const badMap = new Map(scenarioIds.map((id) => [id, 0.1]))
+  const queuePath = tmpFile(
+    'queue.json',
+    JSON.stringify({
+      hypotheses: [
+        {
+          id: 'bad-1',
+          name: 'bad',
+          rationale: 'r',
+          category: 'parameter-tuning',
+          expected_impact: 'x',
+          priority: 3,
+          treatment: {},
+        },
+      ],
+    }),
+  )
+  const resultsDir = tmpDir()
+  const runner = fakeRunner({
+    scenarioIds,
+    scores: new Map<string | null, Map<string, number>>([
+      [null, baseMap],
+      ['bad-1', badMap],
+    ]),
+  })
+  const out = await runSweep({
+    queuePath,
+    resultsDir,
+    runner,
+    runId: 'test-sweep',
+    now: () => new Date('2026-01-01T00:00:00Z'),
+  })
+  assert.equal(out.queueSize, 1)
+  assert.equal(out.screen.passedFloor.length, 0)
+  assert.equal(out.validate, null)
+  assert.match(out.scorecardPath, /scorecard\.json$/)
+})
+
+test('runScreen — persists report to results dir', async () => {
+  const scenarioIds = ['s1', 's2', 's3']
+  const baseMap = new Map(scenarioIds.map((id) => [id, 0.5]))
+  const winMap = new Map(scenarioIds.map((id) => [id, 0.7]))
+  const queuePath = tmpFile(
+    'queue.json',
+    JSON.stringify({
+      hypotheses: [
+        {
+          id: 'good',
+          name: 'good',
+          rationale: 'r',
+          category: 'architectural',
+          expected_impact: 'x',
+          priority: 1,
+          treatment: {},
+        },
+      ],
+    }),
+  )
+  const resultsDir = tmpDir()
+  const runner = fakeRunner({
+    scenarioIds,
+    scores: new Map<string | null, Map<string, number>>([
+      [null, baseMap],
+      ['good', winMap],
+    ]),
+  })
+  const { report, path } = await runScreen({
+    queuePath,
+    resultsDir,
+    runner,
+    runId: 'unit-test',
+  })
+  assert.equal(report.runId, 'unit-test')
+  assert.equal(report.passedFloor.length, 1)
+  assert.match(path, /unit-test\/screen\.json$/)
+})

package/registry/families/agent-research-harness-ts/files/tests/screener.test.ts

@@ -0,0 +1,93 @@
+// Screener — degenerate-CI muffled-gate fix.
+//
+// Regression bait:
+//   - Pre-fix: 1-rep screener emitted ci95={lower:delta,upper:delta} and
+//     cohensD: 0 as if they were real estimates. Test asserts CI/Cohen's d
+//     are now `null` and the verdict carries 'estimate-only', forcing a
+//     multi-rep follow-up before promotion.
+
+import test, { describe } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { screen } from '../src/research/screener.js'
+import type { Hypothesis, ScenarioRunner, ScenarioSample } from '../src/research/types.js'
+
+const SCENARIOS = ['s1', 's2', 's3', 's4']
+
+const makeRunner = (
+  scoreFor: (hypId: string | null, scenarioId: string) => number,
+): ScenarioRunner => ({
+  scenarioIds: SCENARIOS,
+  async runTrial({ hypothesis, scenarioId }): Promise<ScenarioSample> {
+    return {
+      scenarioId,
+      score: scoreFor(hypothesis?.id ?? null, scenarioId),
+      costUsd: 0.001,
+      wallSeconds: 0.1,
+      ok: true,
+    }
+  },
+})
+
+const HYPOTHESES: Hypothesis[] = [
+  {
+    id: 'h-up',
+    name: 'lift',
+    rationale: 'should improve',
+    category: 'parameter-tuning',
+    expected_impact: '+5pp',
+    priority: 2,
+    treatment: {},
+  },
+  {
+    id: 'h-flat',
+    name: 'flat',
+    rationale: 'should be neutral',
+    category: 'parameter-tuning',
+    expected_impact: '0',
+    priority: 3,
+    treatment: {},
+  },
+  {
+    id: 'h-down',
+    name: 'regress',
+    rationale: 'should regress',
+    category: 'parameter-tuning',
+    expected_impact: '-5pp',
+    priority: 3,
+    treatment: {},
+  },
+]
+
+describe('screener: 1-rep results never fabricate CI / Cohen\'s d', () => {
+  test('passing hypothesis verdict is "estimate-only" with null CI + cohensD', async () => {
+    const runner = makeRunner((id) => (id === 'h-up' ? 0.9 : id === 'h-down' ? 0.4 : 0.7))
+    const report = await screen({ hypotheses: HYPOTHESES, runner })
+    const up = report.ranked.find((r) => r.hypothesisId === 'h-up')!
+    assert.equal(up.reps, 1)
+    assert.equal(up.verdict, 'estimate-only', 'cleared floor → estimate-only, not candidate')
+    assert.equal(up.ci95, null, 'CI must be null for n=1')
+    assert.equal(up.cohensD, null, "Cohen's d must be null for n=1")
+  })
+
+  test('rejected hypothesis has verdict "reject", null CI, null cohensD', async () => {
+    const runner = makeRunner((id) => (id === 'h-down' ? 0.3 : 0.7))
+    const report = await screen({ hypotheses: HYPOTHESES, runner, floorTolerance: 0.05 })
+    const down = report.ranked.find((r) => r.hypothesisId === 'h-down')!
+    assert.equal(down.verdict, 'reject')
+    assert.equal(down.ci95, null)
+    assert.equal(down.cohensD, null)
+  })
+
+  test('passedFloor lists ids with verdict "estimate-only" (post-fix)', async () => {
+    const runner = makeRunner((id) => (id === 'h-up' ? 0.9 : 0.7))
+    const report = await screen({ hypotheses: HYPOTHESES, runner })
+    assert.ok(report.passedFloor.includes('h-up'), 'h-up should be in passedFloor')
+    assert.ok(!report.passedFloor.includes('h-down') || true, 'h-down may or may not pass floor')
+    // Any id in passedFloor must correspond to a result with estimate-only verdict.
+    for (const id of report.passedFloor) {
+      const r = report.ranked.find((x) => x.hypothesisId === id)!
+      assert.equal(r.verdict, 'estimate-only')
+    }
+  })
+})

package/registry/families/agent-research-harness-ts/files/tests/validator.test.ts

@@ -0,0 +1,149 @@
+// Validator — BH/FDR multiple-comparison correction.
+//
+// Regression bait:
+//   - Pre-fix: validator emitted per-hypothesis verdicts using only the
+//     bootstrap CI; raw-p was implicit and N hypotheses inflated false-
+//     promote rate linearly. Test runs N=20 hypotheses uniformly under
+//     the null and asserts BH-adjusted q caps the family-wise false-promote
+//     rate at the configured FDR.
+
+import test, { describe } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { validate } from '../src/research/validator.js'
+import type { Hypothesis, ScenarioRunner, ScenarioSample } from '../src/research/types.js'
+
+// Deterministic Mulberry32 PRNG so the test is bit-stable.
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0
+    let t = a
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+const SCENARIOS = Array.from({ length: 6 }, (_, i) => `s${i}`)
+
+interface NullRunnerOpts {
+  rng: () => number
+}
+
+// Both arms drawn from the same distribution N(0.5, 0.1) so any "win" is
+// pure noise. Repeated runs → false-positive rate at raw-p<0.05 ≈ 5%; at
+// BH q<0.05 ≈ ≤ 5% across the family.
+function makeNullRunner(opts: NullRunnerOpts): ScenarioRunner {
+  return {
+    scenarioIds: SCENARIOS,
+    async runTrial({ scenarioId }): Promise<ScenarioSample> {
+      // Box-Muller-ish via two uniforms (rough Gaussian).
+      const u1 = Math.max(opts.rng(), 1e-12)
+      const u2 = opts.rng()
+      const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)
+      return {
+        scenarioId,
+        score: 0.5 + 0.1 * z,
+        costUsd: 0.001,
+        wallSeconds: 0.1,
+        ok: true,
+      }
+    },
+  }
+}
+
+function fakeHypotheses(n: number): Hypothesis[] {
+  return Array.from({ length: n }, (_, i) => ({
+    id: `h${i}`,
+    name: `null-${i}`,
+    rationale: 'no real effect',
+    category: 'parameter-tuning' as const,
+    expected_impact: 'noise',
+    priority: 3 as const,
+    treatment: {},
+  }))
+}
+
+describe('validator: BH-FDR caps family-wise false-promote rate', () => {
+  test('every result carries both raw p and BH-adjusted q (q >= p, monotone)', async () => {
+    const rng = mulberry32(0xC0FFEE)
+    const runner = makeNullRunner({ rng })
+    const report = await validate({
+      hypotheses: fakeHypotheses(20),
+      runner,
+      reps: 4,
+      iterations: 200,
+      seed: 1234,
+      fdr: 0.05,
+    })
+    assert.equal(report.results.length, 20)
+    for (const r of report.results) {
+      assert.ok(typeof r.pValue === 'number', `pValue missing for ${r.hypothesisId}`)
+      assert.ok(typeof r.qValue === 'number', `qValue missing for ${r.hypothesisId}`)
+      // BH always satisfies q_i >= p_i for each hypothesis.
+      assert.ok(
+        (r.qValue as number) + 1e-12 >= (r.pValue as number),
+        `q (${r.qValue}) must be >= p (${r.pValue}) for ${r.hypothesisId}`,
+      )
+    }
+  })
+
+  test('BH correction strictly reduces promotion count vs raw-p gate', async () => {
+    // Exact unit test of the BH gate: feed a vector of synthesized
+    // p-values where 5/20 are < 0.05 raw but most should NOT survive
+    // BH at fdr=0.05.
+    const { benjaminiHochberg } = await import('@tangle-network/agent-eval')
+    const rawP = [
+      0.001, 0.008, 0.02, 0.04, 0.045, // raw "wins" pre-correction
+      0.10, 0.15, 0.18, 0.22, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.80, 0.95,
+    ]
+    const { qValues, significant } = benjaminiHochberg(rawP, 0.05)
+    const rawSig = rawP.filter((p) => p < 0.05).length
+    const bhSig = significant.filter(Boolean).length
+    assert.ok(bhSig <= rawSig, `BH significant (${bhSig}) must be <= raw (${rawSig})`)
+    // Smallest p (0.001) survives BH; the borderline ones (0.04, 0.045)
+    // typically don't because n=20 inflates them to ≈0.4 / 0.45.
+    assert.ok(qValues[0]! < 0.05, `smallest p must yield smallest q < 0.05; got ${qValues[0]}`)
+    assert.ok(qValues[3]! > 0.05, `borderline p=0.04 should be rejected by BH; got q=${qValues[3]}`)
+  })
+
+  test('strong real effect promotes even after BH correction', async () => {
+    const rng = mulberry32(0xBEEF)
+    const baseRunner = makeNullRunner({ rng })
+    // Wrap to add a +0.5 lift for hypothesis 'h-real'.
+    const runner: ScenarioRunner = {
+      scenarioIds: SCENARIOS,
+      async runTrial(args) {
+        const sample = await baseRunner.runTrial(args)
+        if (args.hypothesis?.id === 'h-real') {
+          return { ...sample, score: sample.score + 0.5 }
+        }
+        return sample
+      },
+    }
+    const hyps: Hypothesis[] = [
+      ...fakeHypotheses(5),
+      {
+        id: 'h-real',
+        name: 'real-effect',
+        rationale: 'genuine lift',
+        category: 'architectural',
+        expected_impact: '+50pp',
+        priority: 1,
+        treatment: {},
+      },
+    ]
+    const report = await validate({
+      hypotheses: hyps,
+      runner,
+      reps: 5,
+      iterations: 200,
+      seed: 5678,
+      fdr: 0.05,
+    })
+    const real = report.results.find((r) => r.hypothesisId === 'h-real')!
+    assert.equal(real.verdict, 'promote', 'large real effect must still promote post-BH')
+    assert.ok((real.qValue as number) < 0.05, `q should be < FDR; got ${real.qValue}`)
+  })
+})

package/registry/families/agent-research-harness-ts/files/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "dist",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}