@vitest-agent/reporter 1.0.8 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/LiveInkRenderer.js +1 -1
  2. package/defaultReporter.js +6 -5
  3. package/index.d.ts +336 -348
  4. package/index.js +1 -1
  5. package/package.json +9 -14
  6. package/tsdoc-metadata.json +1 -1
package/LiveInkRenderer.js CHANGED
@@ -1,5 +1,5 @@
1
- import { SPINNER_FRAME_MS, StreamApp, reduceRenderState, spinnerFrameForTime } from "@vitest-agent/ui";
2
1
  import { initialRenderState } from "@vitest-agent/sdk";
2
+ import { SPINNER_FRAME_MS, StreamApp, reduceRenderState, spinnerFrameForTime } from "@vitest-agent/ui";
3
3
  import { Box, render, renderToString } from "ink";
4
4
  import { createElement } from "react";
5
5
 
package/defaultReporter.js CHANGED
@@ -1,6 +1,7 @@
1
1
  import { createLiveInk } from "./LiveInkRenderer.js";
2
+ import { countSuiteFailures } from "@vitest-agent/sdk";
2
3
  import { classifyOutcome, classifyRunShape, dispatch, dispatcherTable, reduceRenderStateAll, synthesizeFromAgentReport } from "@vitest-agent/ui";
3
- import { Effect, PubSub, Queue } from "effect";
4
+ import { Effect, PubSub } from "effect";
4
5
 
5
6
  //#region src/defaultReporter.ts
6
7
  const summarizeProject = (report) => {
@@ -11,7 +12,7 @@ const summarizeProject = (report) => {
11
12
  return {
12
13
  name: report.project ?? "default",
13
14
  passCount: report.summary.passed,
14
- failCount: report.summary.failed,
15
+ failCount: report.summary.failed + countSuiteFailures(report),
15
16
  skipCount: report.summary.skipped,
16
17
  durationMs: report.summary.duration,
17
18
  ...tagCountsHasEntries && collapsedTagCounts !== void 0 ? { tagCounts: collapsedTagCounts } : {},
@@ -151,7 +152,7 @@ const renderGithubSummary = (input) => {
151
152
  * at run start — before the plugin publishes the first `RunStarted`
152
153
  * event — so the subscription is registered in time. `Effect.runFork`
153
154
  * advances the forked fiber up to its first suspension (the
154
- * `Queue.take` below); that suspension point is past `PubSub.subscribe`,
155
+ * `PubSub.take` below); that suspension point is past `PubSub.subscribe`,
155
156
  * so the subscription is live before this function returns. The drain
156
157
  * loop runs forever: `createLiveInk` handles `RunFinished` (schedules
157
158
  * unmount) and a subsequent `RunStarted` (remounts) itself, so the loop
@@ -163,8 +164,8 @@ const renderGithubSummary = (input) => {
163
164
  const subscribeLiveInk = (channel) => {
164
165
  const live = createLiveInk();
165
166
  Effect.runFork(Effect.scoped(Effect.gen(function* () {
166
- const dequeue = yield* PubSub.subscribe(channel);
167
- yield* Effect.forever(Queue.take(dequeue).pipe(Effect.flatMap((event) => Effect.sync(() => live.event(event)))));
167
+ const subscription = yield* PubSub.subscribe(channel);
168
+ yield* Effect.forever(PubSub.take(subscription).pipe(Effect.flatMap((event) => Effect.sync(() => live.event(event)))));
168
169
  })));
169
170
  };
170
171
  /**
package/index.d.ts CHANGED
@@ -1,23 +1,23 @@
1
1
  import { PubSub, Schema } from "effect";
2
- import "@effect/platform";
3
- import "config-file-effect";
4
- import "@effect/sql/SqlClient";
5
- import "workspaces-effect";
6
- import "xdg-effect";
2
+ import "@effected/config-file";
3
+ import "effect/unstable/sql/SqlClient";
4
+ import "@effected/workspaces";
5
+ import "@effected/xdg";
6
+ import "effect/unstable/process";
7
7
  //#region ../sdk/dist/dev/pkg/index.d.ts
8
8
  /**
9
9
  * Per-file coverage data including uncovered line ranges.
10
10
  * @public
11
11
  */
12
12
  declare const FileCoverageReport: Schema.Struct<{
13
- file: typeof Schema.String;
14
- summary: Schema.Struct<{
15
- statements: typeof Schema.Number;
16
- branches: typeof Schema.Number;
17
- functions: typeof Schema.Number;
18
- lines: typeof Schema.Number;
13
+ readonly file: Schema.String;
14
+ readonly summary: Schema.Struct<{
15
+ readonly statements: Schema.Number;
16
+ readonly branches: Schema.Number;
17
+ readonly functions: Schema.Number;
18
+ readonly lines: Schema.Number;
19
19
  }>;
20
- uncoveredLines: typeof Schema.String;
20
+ readonly uncoveredLines: Schema.String;
21
21
  }>;
22
22
  /** @public */
23
23
  type FileCoverageReport = typeof FileCoverageReport.Type;
@@ -33,30 +33,30 @@ type FileCoverageReport = typeof FileCoverageReport.Type;
33
33
  * @public
34
34
  */
35
35
  declare const RenderState: Schema.Struct<{
36
- phase: Schema.Literal<["idle", "running", "finished", "timed-out"]>;
37
- runId: Schema.NullOr<typeof Schema.String>;
38
- configHash: Schema.NullOr<typeof Schema.String>;
39
- startedAt: Schema.NullOr<typeof Schema.String>;
40
- finishedAt: Schema.NullOr<typeof Schema.String>;
41
- modules: Schema.Record$<typeof Schema.String, Schema.Struct<{
42
- modulePath: typeof Schema.String;
43
- status: Schema.Literal<["queued", "running", "finished"]>;
44
- passCount: typeof Schema.Number;
45
- failCount: typeof Schema.Number;
46
- skipCount: typeof Schema.Number;
47
- timeoutCount: typeof Schema.Number;
48
- durationMs: typeof Schema.Number;
49
- tests: Schema.Array$<Schema.Struct<{
50
- testName: typeof Schema.String;
51
- suitePath: Schema.Array$<typeof Schema.String>;
52
- status: Schema.Union<[Schema.Literal<["passed", "failed", "skipped", "pending"]>, Schema.Literal<["running", "timed-out"]>]>;
53
- durationMs: Schema.NullOr<typeof Schema.Number>;
54
- error: Schema.optional<Schema.Struct<{
55
- message: typeof Schema.String;
56
- stack: Schema.optional<typeof Schema.String>;
57
- diff: Schema.optional<typeof Schema.String>;
58
- expected: Schema.optional<typeof Schema.String>;
59
- received: Schema.optional<typeof Schema.String>;
36
+ readonly phase: Schema.Literals<readonly ["idle", "running", "finished", "timed-out"]>;
37
+ readonly runId: Schema.NullOr<Schema.String>;
38
+ readonly configHash: Schema.NullOr<Schema.String>;
39
+ readonly startedAt: Schema.NullOr<Schema.String>;
40
+ readonly finishedAt: Schema.NullOr<Schema.String>;
41
+ readonly modules: Schema.$Record<Schema.String, Schema.Struct<{
42
+ readonly modulePath: Schema.String;
43
+ readonly status: Schema.Literals<readonly ["queued", "running", "finished"]>;
44
+ readonly passCount: Schema.Number;
45
+ readonly failCount: Schema.Number;
46
+ readonly skipCount: Schema.Number;
47
+ readonly timeoutCount: Schema.Number;
48
+ readonly durationMs: Schema.Number;
49
+ readonly tests: Schema.$Array<Schema.Struct<{
50
+ readonly testName: Schema.String;
51
+ readonly suitePath: Schema.$Array<Schema.String>;
52
+ readonly status: Schema.Union<readonly [Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>, Schema.Literals<readonly ["running", "timed-out"]>]>;
53
+ readonly durationMs: Schema.NullOr<Schema.Number>;
54
+ readonly error: Schema.optional<Schema.Struct<{
55
+ readonly message: Schema.String;
56
+ readonly stack: Schema.optional<Schema.String>;
57
+ readonly diff: Schema.optional<Schema.String>;
58
+ readonly expected: Schema.optional<Schema.String>;
59
+ readonly received: Schema.optional<Schema.String>;
60
60
  }>>;
61
61
  }>>;
62
62
  /**
@@ -64,76 +64,76 @@ declare const RenderState: Schema.Struct<{
64
64
  * configs or older replays leave it `undefined`, which the renderer
65
65
  * treats as a single anonymous project.
66
66
  */
67
- projectName: Schema.optional<typeof Schema.String>;
67
+ readonly projectName: Schema.optional<Schema.String>;
68
68
  /**
69
69
  * ISO wall-clock stamp captured at `onTestModuleStart`. The live
70
70
  * renderer derives a ticking elapsed column from it while the module
71
71
  * runs; once finished it shows `durationMs` instead. Optional — a
72
72
  * module seeded by `ModuleQueued` (or replayed) has no start stamp.
73
73
  */
74
- startedAt: Schema.optional<typeof Schema.String>;
75
- tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
74
+ readonly startedAt: Schema.optional<Schema.String>;
75
+ readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
76
76
  }>>;
77
- moduleOrder: Schema.Array$<typeof Schema.String>;
78
- totals: Schema.Struct<{
79
- passCount: typeof Schema.Number;
80
- failCount: typeof Schema.Number;
81
- skipCount: typeof Schema.Number;
82
- timeoutCount: typeof Schema.Number;
83
- durationMs: typeof Schema.Number;
77
+ readonly moduleOrder: Schema.$Array<Schema.String>;
78
+ readonly totals: Schema.Struct<{
79
+ readonly passCount: Schema.Number;
80
+ readonly failCount: Schema.Number;
81
+ readonly skipCount: Schema.Number;
82
+ readonly timeoutCount: Schema.Number;
83
+ readonly durationMs: Schema.Number;
84
84
  }>;
85
- coverage: Schema.NullOr<Schema.Struct<{
86
- metrics: Schema.Struct<{
87
- statements: typeof Schema.Number;
88
- branches: typeof Schema.Number;
89
- functions: typeof Schema.Number;
90
- lines: typeof Schema.Number;
85
+ readonly coverage: Schema.NullOr<Schema.Struct<{
86
+ readonly metrics: Schema.Struct<{
87
+ readonly statements: Schema.Number;
88
+ readonly branches: Schema.Number;
89
+ readonly functions: Schema.Number;
90
+ readonly lines: Schema.Number;
91
91
  }>;
92
- thresholds: Schema.Struct<{
93
- lines: Schema.optional<typeof Schema.Number>;
94
- functions: Schema.optional<typeof Schema.Number>;
95
- branches: Schema.optional<typeof Schema.Number>;
96
- statements: Schema.optional<typeof Schema.Number>;
92
+ readonly thresholds: Schema.Struct<{
93
+ readonly lines: Schema.optional<Schema.Number>;
94
+ readonly functions: Schema.optional<Schema.Number>;
95
+ readonly branches: Schema.optional<Schema.Number>;
96
+ readonly statements: Schema.optional<Schema.Number>;
97
97
  }>;
98
- gaps: Schema.Array$<Schema.Struct<{
99
- file: typeof Schema.String;
100
- missing: Schema.Struct<{
101
- statements: typeof Schema.Number;
102
- branches: typeof Schema.Number;
103
- functions: typeof Schema.Number;
104
- lines: typeof Schema.Number;
98
+ readonly gaps: Schema.$Array<Schema.Struct<{
99
+ readonly file: Schema.String;
100
+ readonly missing: Schema.Struct<{
101
+ readonly statements: Schema.Number;
102
+ readonly branches: Schema.Number;
103
+ readonly functions: Schema.Number;
104
+ readonly lines: Schema.Number;
105
105
  }>;
106
- uncoveredLines: Schema.optional<typeof Schema.String>;
106
+ readonly uncoveredLines: Schema.optional<Schema.String>;
107
107
  }>>;
108
- violations: Schema.Array$<Schema.Struct<{
109
- metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
110
- expected: typeof Schema.Number;
111
- actual: typeof Schema.Number;
108
+ readonly violations: Schema.$Array<Schema.Struct<{
109
+ readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
110
+ readonly expected: Schema.Number;
111
+ readonly actual: Schema.Number;
112
112
  }>>;
113
113
  }>>;
114
- trend: Schema.NullOr<Schema.Struct<{
115
- direction: Schema.Literal<["improving", "regressing", "stable"]>;
116
- runCount: typeof Schema.Number;
114
+ readonly trend: Schema.NullOr<Schema.Struct<{
115
+ readonly direction: Schema.Literals<readonly ["improving", "regressing", "stable"]>;
116
+ readonly runCount: Schema.Number;
117
117
  }>>;
118
- failures: Schema.Array$<Schema.Struct<{
119
- modulePath: typeof Schema.String;
120
- testName: typeof Schema.String;
121
- suitePath: Schema.Array$<typeof Schema.String>;
122
- error: Schema.optional<Schema.Struct<{
123
- message: typeof Schema.String;
124
- stack: Schema.optional<typeof Schema.String>;
125
- diff: Schema.optional<typeof Schema.String>;
126
- expected: Schema.optional<typeof Schema.String>;
127
- received: Schema.optional<typeof Schema.String>;
118
+ readonly failures: Schema.$Array<Schema.Struct<{
119
+ readonly modulePath: Schema.String;
120
+ readonly testName: Schema.String;
121
+ readonly suitePath: Schema.$Array<Schema.String>;
122
+ readonly error: Schema.optional<Schema.Struct<{
123
+ readonly message: Schema.String;
124
+ readonly stack: Schema.optional<Schema.String>;
125
+ readonly diff: Schema.optional<Schema.String>;
126
+ readonly expected: Schema.optional<Schema.String>;
127
+ readonly received: Schema.optional<Schema.String>;
128
128
  }>>;
129
- timedOut: Schema.optional<typeof Schema.Boolean>;
130
- classification: Schema.NullOr<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
129
+ readonly timedOut: Schema.optional<Schema.Boolean>;
130
+ readonly classification: Schema.NullOr<Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
131
131
  }>>;
132
- suggestedActions: Schema.Array$<Schema.Struct<{
133
- severity: Schema.Literal<["info", "warn", "blocker"]>;
134
- title: typeof Schema.String;
135
- detail: typeof Schema.String;
136
- targetTool: Schema.optional<typeof Schema.String>;
132
+ readonly suggestedActions: Schema.$Array<Schema.Struct<{
133
+ readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
134
+ readonly title: Schema.String;
135
+ readonly detail: Schema.String;
136
+ readonly targetTool: Schema.optional<Schema.String>;
137
137
  }>>;
138
138
  }>;
139
139
  /** @public */
@@ -265,149 +265,141 @@ interface CellOptions {
265
265
  * @public
266
266
  */
267
267
  declare const AgentReport: Schema.Struct<{
268
- timestamp: typeof Schema.String;
269
- project: Schema.optional<typeof Schema.String>;
270
- reason: Schema.Literal<["passed", "failed", "interrupted"]>;
271
- summary: Schema.Struct<{
272
- total: typeof Schema.Number;
273
- passed: typeof Schema.Number;
274
- failed: typeof Schema.Number;
275
- skipped: typeof Schema.Number;
276
- duration: typeof Schema.Number;
268
+ readonly timestamp: Schema.String;
269
+ readonly project: Schema.optional<Schema.String>;
270
+ readonly reason: Schema.Literals<readonly ["passed", "failed", "interrupted"]>;
271
+ readonly summary: Schema.Struct<{
272
+ readonly total: Schema.Number;
273
+ readonly passed: Schema.Number;
274
+ readonly failed: Schema.Number;
275
+ readonly skipped: Schema.Number;
276
+ readonly duration: Schema.Number;
277
277
  }>;
278
- failed: Schema.Array$<Schema.Struct<{
279
- file: typeof Schema.String;
280
- state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
281
- duration: Schema.optional<typeof Schema.Number>;
282
- errors: Schema.optional<Schema.Array$<Schema.Struct<{
283
- message: typeof Schema.String;
284
- stack: Schema.optional<typeof Schema.String>;
285
- diff: Schema.optional<typeof Schema.String>;
286
- expected: Schema.optional<typeof Schema.String>;
287
- received: Schema.optional<typeof Schema.String>;
278
+ readonly failed: Schema.$Array<Schema.Struct<{
279
+ readonly file: Schema.String;
280
+ readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
281
+ readonly duration: Schema.optional<Schema.Number>;
282
+ readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
283
+ readonly message: Schema.String;
284
+ readonly stack: Schema.optional<Schema.String>;
285
+ readonly diff: Schema.optional<Schema.String>;
286
+ readonly expected: Schema.optional<Schema.String>;
287
+ readonly received: Schema.optional<Schema.String>;
288
288
  }>>>;
289
- tests: Schema.Array$<Schema.Struct<{
290
- name: typeof Schema.String;
291
- fullName: typeof Schema.String;
292
- state: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
293
- duration: Schema.optional<typeof Schema.Number>;
294
- flaky: Schema.optional<typeof Schema.Boolean>;
295
- slow: Schema.optional<typeof Schema.Boolean>;
296
- errors: Schema.optional<Schema.Array$<Schema.Struct<{
297
- message: typeof Schema.String;
298
- stack: Schema.optional<typeof Schema.String>;
299
- diff: Schema.optional<typeof Schema.String>;
300
- expected: Schema.optional<typeof Schema.String>;
301
- received: Schema.optional<typeof Schema.String>;
289
+ readonly tests: Schema.$Array<Schema.Struct<{
290
+ readonly name: Schema.String;
291
+ readonly fullName: Schema.String;
292
+ readonly state: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
293
+ readonly duration: Schema.optional<Schema.Number>;
294
+ readonly flaky: Schema.optional<Schema.Boolean>;
295
+ readonly slow: Schema.optional<Schema.Boolean>;
296
+ readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
297
+ readonly message: Schema.String;
298
+ readonly stack: Schema.optional<Schema.String>;
299
+ readonly diff: Schema.optional<Schema.String>;
300
+ readonly expected: Schema.optional<Schema.String>;
301
+ readonly received: Schema.optional<Schema.String>;
302
302
  }>>>;
303
- classification: Schema.optional<Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
303
+ readonly classification: Schema.optional<Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>>;
304
304
  }>>;
305
305
  }>>;
306
- unhandledErrors: Schema.Array$<Schema.Struct<{
307
- message: typeof Schema.String;
308
- stack: Schema.optional<typeof Schema.String>;
309
- diff: Schema.optional<typeof Schema.String>;
310
- expected: Schema.optional<typeof Schema.String>;
311
- received: Schema.optional<typeof Schema.String>;
306
+ readonly unhandledErrors: Schema.$Array<Schema.Struct<{
307
+ readonly message: Schema.String;
308
+ readonly stack: Schema.optional<Schema.String>;
309
+ readonly diff: Schema.optional<Schema.String>;
310
+ readonly expected: Schema.optional<Schema.String>;
311
+ readonly received: Schema.optional<Schema.String>;
312
312
  }>>;
313
- failedFiles: Schema.Array$<typeof Schema.String>;
314
- coverage: Schema.optional<Schema.Struct<{
315
- totals: Schema.Struct<{
316
- statements: typeof Schema.Number;
317
- branches: typeof Schema.Number;
318
- functions: typeof Schema.Number;
319
- lines: typeof Schema.Number;
313
+ readonly failedFiles: Schema.$Array<Schema.String>;
314
+ readonly coverage: Schema.optional<Schema.Struct<{
315
+ readonly totals: Schema.Struct<{
316
+ readonly statements: Schema.Number;
317
+ readonly branches: Schema.Number;
318
+ readonly functions: Schema.Number;
319
+ readonly lines: Schema.Number;
320
320
  }>;
321
- thresholds: Schema.Struct<{
322
- global: Schema.Struct<{
323
- lines: Schema.optional<typeof Schema.Number>;
324
- functions: Schema.optional<typeof Schema.Number>;
325
- branches: Schema.optional<typeof Schema.Number>;
326
- statements: Schema.optional<typeof Schema.Number>;
327
- }>;
328
- patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
329
- lines: Schema.optional<typeof Schema.Number>;
330
- functions: Schema.optional<typeof Schema.Number>;
331
- branches: Schema.optional<typeof Schema.Number>;
332
- statements: Schema.optional<typeof Schema.Number>;
333
- }>>>, {
334
- default: () => never[];
321
+ readonly thresholds: Schema.Struct<{
322
+ readonly global: Schema.Struct<{
323
+ readonly lines: Schema.optional<Schema.Number>;
324
+ readonly functions: Schema.optional<Schema.Number>;
325
+ readonly branches: Schema.optional<Schema.Number>;
326
+ readonly statements: Schema.optional<Schema.Number>;
335
327
  }>;
328
+ readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
329
+ readonly lines: Schema.optional<Schema.Number>;
330
+ readonly functions: Schema.optional<Schema.Number>;
331
+ readonly branches: Schema.optional<Schema.Number>;
332
+ readonly statements: Schema.optional<Schema.Number>;
333
+ }>]>>, never>;
336
334
  }>;
337
- targets: Schema.optional<Schema.Struct<{
338
- global: Schema.Struct<{
339
- lines: Schema.optional<typeof Schema.Number>;
340
- functions: Schema.optional<typeof Schema.Number>;
341
- branches: Schema.optional<typeof Schema.Number>;
342
- statements: Schema.optional<typeof Schema.Number>;
343
- }>;
344
- patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
345
- lines: Schema.optional<typeof Schema.Number>;
346
- functions: Schema.optional<typeof Schema.Number>;
347
- branches: Schema.optional<typeof Schema.Number>;
348
- statements: Schema.optional<typeof Schema.Number>;
349
- }>>>, {
350
- default: () => never[];
335
+ readonly targets: Schema.optional<Schema.Struct<{
336
+ readonly global: Schema.Struct<{
337
+ readonly lines: Schema.optional<Schema.Number>;
338
+ readonly functions: Schema.optional<Schema.Number>;
339
+ readonly branches: Schema.optional<Schema.Number>;
340
+ readonly statements: Schema.optional<Schema.Number>;
351
341
  }>;
342
+ readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
343
+ readonly lines: Schema.optional<Schema.Number>;
344
+ readonly functions: Schema.optional<Schema.Number>;
345
+ readonly branches: Schema.optional<Schema.Number>;
346
+ readonly statements: Schema.optional<Schema.Number>;
347
+ }>]>>, never>;
352
348
  }>>;
353
- baselines: Schema.optional<Schema.Struct<{
354
- global: Schema.Struct<{
355
- lines: Schema.optional<typeof Schema.Number>;
356
- functions: Schema.optional<typeof Schema.Number>;
357
- branches: Schema.optional<typeof Schema.Number>;
358
- statements: Schema.optional<typeof Schema.Number>;
359
- }>;
360
- patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
361
- lines: Schema.optional<typeof Schema.Number>;
362
- functions: Schema.optional<typeof Schema.Number>;
363
- branches: Schema.optional<typeof Schema.Number>;
364
- statements: Schema.optional<typeof Schema.Number>;
365
- }>>>, {
366
- default: () => never[];
349
+ readonly baselines: Schema.optional<Schema.Struct<{
350
+ readonly global: Schema.Struct<{
351
+ readonly lines: Schema.optional<Schema.Number>;
352
+ readonly functions: Schema.optional<Schema.Number>;
353
+ readonly branches: Schema.optional<Schema.Number>;
354
+ readonly statements: Schema.optional<Schema.Number>;
367
355
  }>;
356
+ readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
357
+ readonly lines: Schema.optional<Schema.Number>;
358
+ readonly functions: Schema.optional<Schema.Number>;
359
+ readonly branches: Schema.optional<Schema.Number>;
360
+ readonly statements: Schema.optional<Schema.Number>;
361
+ }>]>>, never>;
368
362
  }>>;
369
- scoped: Schema.optionalWith<typeof Schema.Boolean, {
370
- default: () => false;
371
- }>;
372
- scopedFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
373
- lowCoverage: Schema.Array$<Schema.Struct<{
374
- file: typeof Schema.String;
375
- summary: Schema.Struct<{
376
- statements: typeof Schema.Number;
377
- branches: typeof Schema.Number;
378
- functions: typeof Schema.Number;
379
- lines: typeof Schema.Number;
363
+ readonly scoped: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
364
+ readonly scopedFiles: Schema.optional<Schema.$Array<Schema.String>>;
365
+ readonly lowCoverage: Schema.$Array<Schema.Struct<{
366
+ readonly file: Schema.String;
367
+ readonly summary: Schema.Struct<{
368
+ readonly statements: Schema.Number;
369
+ readonly branches: Schema.Number;
370
+ readonly functions: Schema.Number;
371
+ readonly lines: Schema.Number;
380
372
  }>;
381
- uncoveredLines: typeof Schema.String;
373
+ readonly uncoveredLines: Schema.String;
382
374
  }>>;
383
- lowCoverageFiles: Schema.Array$<typeof Schema.String>;
384
- belowTarget: Schema.optional<Schema.Array$<Schema.Struct<{
385
- file: typeof Schema.String;
386
- summary: Schema.Struct<{
387
- statements: typeof Schema.Number;
388
- branches: typeof Schema.Number;
389
- functions: typeof Schema.Number;
390
- lines: typeof Schema.Number;
375
+ readonly lowCoverageFiles: Schema.$Array<Schema.String>;
376
+ readonly belowTarget: Schema.optional<Schema.$Array<Schema.Struct<{
377
+ readonly file: Schema.String;
378
+ readonly summary: Schema.Struct<{
379
+ readonly statements: Schema.Number;
380
+ readonly branches: Schema.Number;
381
+ readonly functions: Schema.Number;
382
+ readonly lines: Schema.Number;
391
383
  }>;
392
- uncoveredLines: typeof Schema.String;
384
+ readonly uncoveredLines: Schema.String;
393
385
  }>>>;
394
- belowTargetFiles: Schema.optional<Schema.Array$<typeof Schema.String>>;
386
+ readonly belowTargetFiles: Schema.optional<Schema.$Array<Schema.String>>;
395
387
  }>>;
396
- tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, Schema.Struct<{
397
- passed: Schema.optional<typeof Schema.Number>;
398
- failed: Schema.optional<typeof Schema.Number>;
399
- skipped: Schema.optional<typeof Schema.Number>;
388
+ readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
389
+ readonly passed: Schema.optional<Schema.Number>;
390
+ readonly failed: Schema.optional<Schema.Number>;
391
+ readonly skipped: Schema.optional<Schema.Number>;
400
392
  }>>>;
401
- consoleLeaks: Schema.optional<Schema.Struct<{
402
- total: typeof Schema.Number;
403
- byFile: Schema.Array$<Schema.Struct<{
404
- file: typeof Schema.String;
405
- stdout: typeof Schema.Number;
406
- stderr: typeof Schema.Number;
407
- tests: Schema.optional<Schema.Array$<typeof Schema.String>>;
408
- sample: Schema.optional<typeof Schema.String>;
393
+ readonly consoleLeaks: Schema.optional<Schema.Struct<{
394
+ readonly total: Schema.Number;
395
+ readonly byFile: Schema.$Array<Schema.Struct<{
396
+ readonly file: Schema.String;
397
+ readonly stdout: Schema.Number;
398
+ readonly stderr: Schema.Number;
399
+ readonly tests: Schema.optional<Schema.$Array<Schema.String>>;
400
+ readonly sample: Schema.optional<Schema.String>;
409
401
  }>>;
410
- truncated: Schema.optional<typeof Schema.Boolean>;
402
+ readonly truncated: Schema.optional<Schema.Boolean>;
411
403
  }>>;
412
404
  }>;
413
405
  /** @public */
@@ -416,7 +408,7 @@ type AgentReport = typeof AgentReport.Type;
416
408
  * Classification of a test's failure history across runs.
417
409
  * @public
418
410
  */
419
- declare const TestClassification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
411
+ declare const TestClassification: Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>;
420
412
  /** @public */
421
413
  type TestClassification = typeof TestClassification.Type;
422
414
  /**
@@ -424,35 +416,35 @@ type TestClassification = typeof TestClassification.Type;
424
416
  * Useful for type-narrowing in renderers that take the resolved value.
425
417
  * @public
426
418
  */
427
- declare const ConsoleMode: Schema.Union<[Schema.Literal<["passthrough", "silent", "stream", "agent"]>, Schema.Literal<["passthrough", "silent", "agent"]>, Schema.Literal<["passthrough", "silent", "ci-annotations"]>]>;
419
+ declare const ConsoleMode: Schema.Union<readonly [Schema.Literals<readonly ["passthrough", "silent", "stream", "agent"]>, Schema.Literals<readonly ["passthrough", "silent", "agent"]>, Schema.Literals<readonly ["passthrough", "silent", "ci-annotations"]>]>;
428
420
  /** @public */
429
421
  type ConsoleMode = typeof ConsoleMode.Type;
430
422
  /**
431
423
  * Runtime environment where tests are being executed.
432
424
  * @public
433
425
  */
434
- declare const Environment: Schema.Literal<["agent-shell", "terminal", "ci-github", "ci-generic"]>;
426
+ declare const Environment: Schema.Literals<readonly ["agent-shell", "terminal", "ci-github", "ci-generic"]>;
435
427
  /** @public */
436
428
  type Environment = typeof Environment.Type;
437
429
  /**
438
430
  * Who or what is executing the test run.
439
431
  * @public
440
432
  */
441
- declare const Executor: Schema.Literal<["human", "agent", "ci"]>;
433
+ declare const Executor: Schema.Literals<readonly ["human", "agent", "ci"]>;
442
434
  /** @public */
443
435
  type Executor = typeof Executor.Type;
444
436
  /**
445
437
  * Output format for the reporter pipeline.
446
438
  * @public
447
439
  */
448
- declare const OutputFormat: Schema.Literal<["terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations"]>;
440
+ declare const OutputFormat: Schema.Literals<readonly ["terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations"]>;
449
441
  /** @public */
450
442
  type OutputFormat = typeof OutputFormat.Type;
451
443
  /**
452
444
  * Level of detail in reporter output.
453
445
  * @public
454
446
  */
455
- declare const DetailLevel: Schema.Literal<["minimal", "neutral", "standard", "verbose"]>;
447
+ declare const DetailLevel: Schema.Literals<readonly ["minimal", "neutral", "standard", "verbose"]>;
456
448
  /** @public */
457
449
  type DetailLevel = typeof DetailLevel.Type;
458
450
  //#endregion
@@ -473,144 +465,144 @@ interface RenderedOutput {
473
465
  * been updated to consume the new state shape.
474
466
  * @public
475
467
  */
476
- declare const RunEvent: Schema.Union<[Schema.TaggedStruct<"RunStarted", {
477
- runId: typeof Schema.String;
478
- startedAt: typeof Schema.String;
479
- configHash: typeof Schema.String;
468
+ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted", {
469
+ readonly runId: Schema.String;
470
+ readonly startedAt: Schema.String;
471
+ readonly configHash: Schema.String;
480
472
  }>, Schema.TaggedStruct<"ModuleQueued", {
481
- modulePath: typeof Schema.String;
482
- projectName: Schema.optional<typeof Schema.String>;
473
+ readonly modulePath: Schema.String;
474
+ readonly projectName: Schema.optional<Schema.String>;
483
475
  }>, Schema.TaggedStruct<"ModuleStarted", {
484
- modulePath: typeof Schema.String;
485
- startedAt: typeof Schema.String;
486
- projectName: Schema.optional<typeof Schema.String>;
476
+ readonly modulePath: Schema.String;
477
+ readonly startedAt: Schema.String;
478
+ readonly projectName: Schema.optional<Schema.String>;
487
479
  }>, Schema.TaggedStruct<"TestStarted", {
488
- modulePath: typeof Schema.String;
489
- testName: typeof Schema.String;
490
- suitePath: Schema.Array$<typeof Schema.String>;
480
+ readonly modulePath: Schema.String;
481
+ readonly testName: Schema.String;
482
+ readonly suitePath: Schema.$Array<Schema.String>;
491
483
  }>, Schema.TaggedStruct<"TestFinished", {
492
- modulePath: typeof Schema.String;
493
- testName: typeof Schema.String;
494
- suitePath: Schema.Array$<typeof Schema.String>;
495
- status: Schema.Literal<["passed", "failed", "skipped", "pending"]>;
496
- durationMs: typeof Schema.Number;
497
- error: Schema.optional<Schema.Struct<{
498
- message: typeof Schema.String;
499
- stack: Schema.optional<typeof Schema.String>;
500
- diff: Schema.optional<typeof Schema.String>;
501
- expected: Schema.optional<typeof Schema.String>;
502
- received: Schema.optional<typeof Schema.String>;
484
+ readonly modulePath: Schema.String;
485
+ readonly testName: Schema.String;
486
+ readonly suitePath: Schema.$Array<Schema.String>;
487
+ readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
488
+ readonly durationMs: Schema.Number;
489
+ readonly error: Schema.optional<Schema.Struct<{
490
+ readonly message: Schema.String;
491
+ readonly stack: Schema.optional<Schema.String>;
492
+ readonly diff: Schema.optional<Schema.String>;
493
+ readonly expected: Schema.optional<Schema.String>;
494
+ readonly received: Schema.optional<Schema.String>;
503
495
  }>>;
504
- timedOut: Schema.optional<typeof Schema.Boolean>;
496
+ readonly timedOut: Schema.optional<Schema.Boolean>;
505
497
  }>, Schema.TaggedStruct<"ModuleFinished", {
506
- modulePath: typeof Schema.String;
507
- passCount: typeof Schema.Number;
508
- failCount: typeof Schema.Number;
509
- skipCount: typeof Schema.Number;
510
- durationMs: typeof Schema.Number;
511
- projectName: Schema.optional<typeof Schema.String>;
512
- timeoutCount: Schema.optional<typeof Schema.Number>;
513
- tagCounts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
498
+ readonly modulePath: Schema.String;
499
+ readonly passCount: Schema.Number;
500
+ readonly failCount: Schema.Number;
501
+ readonly skipCount: Schema.Number;
502
+ readonly durationMs: Schema.Number;
503
+ readonly projectName: Schema.optional<Schema.String>;
504
+ readonly timeoutCount: Schema.optional<Schema.Number>;
505
+ readonly tagCounts: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
514
506
  }>, Schema.TaggedStruct<"ModuleCollected", {
515
- modulePath: typeof Schema.String;
516
- testCount: typeof Schema.Number;
517
- suiteCount: typeof Schema.Number;
507
+ readonly modulePath: Schema.String;
508
+ readonly testCount: Schema.Number;
509
+ readonly suiteCount: Schema.Number;
518
510
  }>, Schema.TaggedStruct<"SuiteStarted", {
519
- modulePath: typeof Schema.String;
520
- suitePath: Schema.Array$<typeof Schema.String>;
521
- suiteName: typeof Schema.String;
511
+ readonly modulePath: Schema.String;
512
+ readonly suitePath: Schema.$Array<Schema.String>;
513
+ readonly suiteName: Schema.String;
522
514
  }>, Schema.TaggedStruct<"SuiteFinished", {
523
- modulePath: typeof Schema.String;
524
- suitePath: Schema.Array$<typeof Schema.String>;
525
- suiteName: typeof Schema.String;
526
- passCount: typeof Schema.Number;
527
- failCount: typeof Schema.Number;
528
- skipCount: typeof Schema.Number;
515
+ readonly modulePath: Schema.String;
516
+ readonly suitePath: Schema.$Array<Schema.String>;
517
+ readonly suiteName: Schema.String;
518
+ readonly passCount: Schema.Number;
519
+ readonly failCount: Schema.Number;
520
+ readonly skipCount: Schema.Number;
529
521
  }>, Schema.TaggedStruct<"HookStarted", {
530
- modulePath: typeof Schema.String;
531
- hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
532
- scopeName: typeof Schema.String;
522
+ readonly modulePath: Schema.String;
523
+ readonly hookType: Schema.Literals<readonly ["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
524
+ readonly scopeName: Schema.String;
533
525
  }>, Schema.TaggedStruct<"HookFinished", {
534
- modulePath: typeof Schema.String;
535
- hookType: Schema.Literal<["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
536
- scopeName: typeof Schema.String;
537
- durationMs: typeof Schema.Number;
538
- status: Schema.Literal<["passed", "failed"]>;
539
- error: Schema.optional<Schema.Struct<{
540
- message: typeof Schema.String;
541
- stack: Schema.optional<typeof Schema.String>;
542
- diff: Schema.optional<typeof Schema.String>;
543
- expected: Schema.optional<typeof Schema.String>;
544
- received: Schema.optional<typeof Schema.String>;
526
+ readonly modulePath: Schema.String;
527
+ readonly hookType: Schema.Literals<readonly ["beforeAll", "afterAll", "beforeEach", "afterEach"]>;
528
+ readonly scopeName: Schema.String;
529
+ readonly durationMs: Schema.Number;
530
+ readonly status: Schema.Literals<readonly ["passed", "failed"]>;
531
+ readonly error: Schema.optional<Schema.Struct<{
532
+ readonly message: Schema.String;
533
+ readonly stack: Schema.optional<Schema.String>;
534
+ readonly diff: Schema.optional<Schema.String>;
535
+ readonly expected: Schema.optional<Schema.String>;
536
+ readonly received: Schema.optional<Schema.String>;
545
537
  }>>;
546
538
  }>, Schema.TaggedStruct<"ConsoleLog", {
547
- modulePath: Schema.optional<typeof Schema.String>;
548
- testName: Schema.optional<typeof Schema.String>;
549
- level: Schema.Literal<["stdout", "stderr"]>;
550
- content: typeof Schema.String;
551
- time: typeof Schema.Number;
539
+ readonly modulePath: Schema.optional<Schema.String>;
540
+ readonly testName: Schema.optional<Schema.String>;
541
+ readonly level: Schema.Literals<readonly ["stdout", "stderr"]>;
542
+ readonly content: Schema.String;
543
+ readonly time: Schema.Number;
552
544
  }>, Schema.TaggedStruct<"RunTimedOut", {
553
- message: typeof Schema.String;
545
+ readonly message: Schema.String;
554
546
  }>, Schema.TaggedStruct<"TestAnnotated", {
555
- modulePath: typeof Schema.String;
556
- testName: typeof Schema.String;
557
- suitePath: Schema.Array$<typeof Schema.String>;
558
- annotation: typeof Schema.String;
547
+ readonly modulePath: Schema.String;
548
+ readonly testName: Schema.String;
549
+ readonly suitePath: Schema.$Array<Schema.String>;
550
+ readonly annotation: Schema.String;
559
551
  }>, Schema.TaggedStruct<"TestArtifactRecorded", {
560
- modulePath: typeof Schema.String;
561
- testName: typeof Schema.String;
562
- suitePath: Schema.Array$<typeof Schema.String>;
563
- artifact: typeof Schema.String;
552
+ readonly modulePath: Schema.String;
553
+ readonly testName: Schema.String;
554
+ readonly suitePath: Schema.$Array<Schema.String>;
555
+ readonly artifact: Schema.String;
564
556
  }>, Schema.TaggedStruct<"WatcherReady", {}>, Schema.TaggedStruct<"WatcherRerun", {
565
- triggerFiles: Schema.Array$<typeof Schema.String>;
566
- reason: Schema.optional<typeof Schema.String>;
557
+ readonly triggerFiles: Schema.$Array<Schema.String>;
558
+ readonly reason: Schema.optional<Schema.String>;
567
559
  }>, Schema.TaggedStruct<"TrendComputed", {
568
- direction: Schema.Literal<["improving", "regressing", "stable"]>;
569
- runCount: typeof Schema.Number;
560
+ readonly direction: Schema.Literals<readonly ["improving", "regressing", "stable"]>;
561
+ readonly runCount: Schema.Number;
570
562
  }>, Schema.TaggedStruct<"CoverageReady", {
571
- metrics: Schema.Struct<{
572
- statements: typeof Schema.Number;
573
- branches: typeof Schema.Number;
574
- functions: typeof Schema.Number;
575
- lines: typeof Schema.Number;
563
+ readonly metrics: Schema.Struct<{
564
+ readonly statements: Schema.Number;
565
+ readonly branches: Schema.Number;
566
+ readonly functions: Schema.Number;
567
+ readonly lines: Schema.Number;
576
568
  }>;
577
- thresholds: Schema.Struct<{
578
- lines: Schema.optional<typeof Schema.Number>;
579
- functions: Schema.optional<typeof Schema.Number>;
580
- branches: Schema.optional<typeof Schema.Number>;
581
- statements: Schema.optional<typeof Schema.Number>;
569
+ readonly thresholds: Schema.Struct<{
570
+ readonly lines: Schema.optional<Schema.Number>;
571
+ readonly functions: Schema.optional<Schema.Number>;
572
+ readonly branches: Schema.optional<Schema.Number>;
573
+ readonly statements: Schema.optional<Schema.Number>;
582
574
  }>;
583
- gaps: Schema.Array$<Schema.Struct<{
584
- file: typeof Schema.String;
585
- missing: Schema.Struct<{
586
- statements: typeof Schema.Number;
587
- branches: typeof Schema.Number;
588
- functions: typeof Schema.Number;
589
- lines: typeof Schema.Number;
575
+ readonly gaps: Schema.$Array<Schema.Struct<{
576
+ readonly file: Schema.String;
577
+ readonly missing: Schema.Struct<{
578
+ readonly statements: Schema.Number;
579
+ readonly branches: Schema.Number;
580
+ readonly functions: Schema.Number;
581
+ readonly lines: Schema.Number;
590
582
  }>;
591
- uncoveredLines: Schema.optional<typeof Schema.String>;
583
+ readonly uncoveredLines: Schema.optional<Schema.String>;
592
584
  }>>;
593
585
  }>, Schema.TaggedStruct<"ThresholdViolation", {
594
- metric: Schema.Literal<["lines", "branches", "functions", "statements"]>;
595
- expected: typeof Schema.Number;
596
- actual: typeof Schema.Number;
586
+ readonly metric: Schema.Literals<readonly ["lines", "branches", "functions", "statements"]>;
587
+ readonly expected: Schema.Number;
588
+ readonly actual: Schema.Number;
597
589
  }>, Schema.TaggedStruct<"FailureClassified", {
598
- modulePath: typeof Schema.String;
599
- testName: typeof Schema.String;
600
- classification: Schema.Literal<["stable", "new-failure", "persistent", "flaky", "recovered"]>;
590
+ readonly modulePath: Schema.String;
591
+ readonly testName: Schema.String;
592
+ readonly classification: Schema.Literals<readonly ["stable", "new-failure", "persistent", "flaky", "recovered"]>;
601
593
  }>, Schema.TaggedStruct<"SuggestedAction", {
602
- severity: Schema.Literal<["info", "warn", "blocker"]>;
603
- title: typeof Schema.String;
604
- detail: typeof Schema.String;
605
- targetTool: Schema.optional<typeof Schema.String>;
594
+ readonly severity: Schema.Literals<readonly ["info", "warn", "blocker"]>;
595
+ readonly title: Schema.String;
596
+ readonly detail: Schema.String;
597
+ readonly targetTool: Schema.optional<Schema.String>;
606
598
  }>, Schema.TaggedStruct<"RunFinished", {
607
- runId: typeof Schema.String;
608
- finishedAt: typeof Schema.String;
609
- passCount: typeof Schema.Number;
610
- failCount: typeof Schema.Number;
611
- skipCount: typeof Schema.Number;
612
- durationMs: typeof Schema.Number;
613
- timeoutCount: Schema.optional<typeof Schema.Number>;
599
+ readonly runId: Schema.String;
600
+ readonly finishedAt: Schema.String;
601
+ readonly passCount: Schema.Number;
602
+ readonly failCount: Schema.Number;
603
+ readonly skipCount: Schema.Number;
604
+ readonly durationMs: Schema.Number;
605
+ readonly timeoutCount: Schema.optional<Schema.Number>;
614
606
  }>]>;
615
607
  /** @public */
616
608
  type RunEvent = typeof RunEvent.Type;
@@ -619,23 +611,19 @@ type RunEvent = typeof RunEvent.Type;
619
611
  * @public
620
612
  */
621
613
  declare const ResolvedThresholds: Schema.Struct<{
622
- global: Schema.Struct<{
623
- lines: Schema.optional<typeof Schema.Number>;
624
- functions: Schema.optional<typeof Schema.Number>;
625
- branches: Schema.optional<typeof Schema.Number>;
626
- statements: Schema.optional<typeof Schema.Number>;
627
- }>;
628
- perFile: Schema.optionalWith<typeof Schema.Boolean, {
629
- default: () => false;
630
- }>;
631
- patterns: Schema.optionalWith<Schema.Array$<Schema.Tuple2<typeof Schema.String, Schema.Struct<{
632
- lines: Schema.optional<typeof Schema.Number>;
633
- functions: Schema.optional<typeof Schema.Number>;
634
- branches: Schema.optional<typeof Schema.Number>;
635
- statements: Schema.optional<typeof Schema.Number>;
636
- }>>>, {
637
- default: () => never[];
614
+ readonly global: Schema.Struct<{
615
+ readonly lines: Schema.optional<Schema.Number>;
616
+ readonly functions: Schema.optional<Schema.Number>;
617
+ readonly branches: Schema.optional<Schema.Number>;
618
+ readonly statements: Schema.optional<Schema.Number>;
638
619
  }>;
620
+ readonly perFile: Schema.withDecodingDefaultKey<Schema.Boolean, never>;
621
+ readonly patterns: Schema.withDecodingDefaultKey<Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Struct<{
622
+ readonly lines: Schema.optional<Schema.Number>;
623
+ readonly functions: Schema.optional<Schema.Number>;
624
+ readonly branches: Schema.optional<Schema.Number>;
625
+ readonly statements: Schema.optional<Schema.Number>;
626
+ }>]>>, never>;
639
627
  }>;
640
628
  /** @public */
641
629
  type ResolvedThresholds = typeof ResolvedThresholds.Type;
@@ -650,9 +638,9 @@ type ResolvedThresholds = typeof ResolvedThresholds.Type;
650
638
  * diff and no breaking API change at the call site.
651
639
  * @public
652
640
  */
653
- declare const Transport: Schema.Struct<{
654
- kind: Schema.Literal<["local"]>;
655
- }>;
641
+ declare const Transport: Schema.Union<readonly [Schema.Struct<{
642
+ readonly kind: Schema.Literal<"local">;
643
+ }>]>;
656
644
  /** @public */
657
645
  type Transport = typeof Transport.Type;
658
646
  //#endregion
package/index.js CHANGED
@@ -9,7 +9,7 @@ import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForRe
9
9
  *
10
10
  * @public
11
11
  */
12
- const CURRENT_REPORTER_VERSION = "1.0.8";
12
+ const CURRENT_REPORTER_VERSION = "2.0.0";
13
13
 
14
14
  //#endregion
15
15
  export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, createLiveInk as _createLiveInk, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@vitest-agent/reporter",
3
- "version": "1.0.8",
3
+ "version": "2.0.0",
4
4
  "private": false,
5
5
  "description": "Named VitestAgentReporterFactory implementations for the vitest-agent ecosystem.",
6
6
  "keywords": [
@@ -33,23 +33,18 @@
33
33
  "exports": {
34
34
  ".": {
35
35
  "types": "./index.d.ts",
36
- "import": "./index.js"
36
+ "import": "./index.js",
37
+ "default": "./index.js"
37
38
  },
38
39
  "./package.json": "./package.json"
39
40
  },
40
41
  "dependencies": {
41
- "@effect/cluster": "^0.59.0",
42
- "@effect/experimental": "^0.60.0",
43
- "@effect/platform": "^0.96.2",
44
- "@effect/platform-node": "^0.107.0",
45
- "@effect/rpc": "^0.75.1",
46
- "@effect/sql": "^0.51.1",
47
- "@effect/sql-sqlite-node": "^0.52.0",
48
- "@effect/workflow": "^0.18.2",
49
- "@vitest-agent/sdk": "1.3.4",
50
- "@vitest-agent/ui": "1.1.2",
51
- "effect": "^3.21.4",
52
- "ink": "^7.1.0",
42
+ "@effect/platform-node": "4.0.0-beta.98",
43
+ "@effect/sql-sqlite-node": "4.0.0-beta.98",
44
+ "@vitest-agent/sdk": "2.0.0",
45
+ "@vitest-agent/ui": "2.0.0",
46
+ "effect": "4.0.0-beta.98",
47
+ "ink": "^7.1.1",
53
48
  "react": "^19.2.7"
54
49
  },
55
50
  "peerDependencies": {
package/tsdoc-metadata.json CHANGED
@@ -5,7 +5,7 @@
5
5
  "toolPackages": [
6
6
  {
7
7
  "packageName": "@microsoft/api-extractor",
8
- "packageVersion": "7.58.9"
8
+ "packageVersion": "7.58.10"
9
9
  }
10
10
  ]
11
11
  }