@under18dev/veritas-reports 0.0.0-stage → 0.1.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.
@@ -0,0 +1,669 @@
1
+ import { z } from 'zod';
2
+ declare const Statement: z.ZodObject<{
3
+ id: z.ZodString;
4
+ sourceId: z.ZodString;
5
+ range: z.ZodObject<{
6
+ start: z.ZodNumber;
7
+ end: z.ZodNumber;
8
+ }, z.core.$strip>;
9
+ quote: z.ZodString;
10
+ modality: z.ZodString;
11
+ flags: z.ZodArray<z.ZodString>;
12
+ }, z.core.$strip>;
13
+ /** An improvement plan made from this run, with its apply attempts (before/after measurements). */
14
+ declare const Improvement: z.ZodObject<{
15
+ planId: z.ZodString;
16
+ outcome: z.ZodString;
17
+ goal: z.ZodNullable<z.ZodString>;
18
+ proposedTests: z.ZodArray<z.ZodString>;
19
+ patchPreview: z.ZodString;
20
+ reasons: z.ZodArray<z.ZodString>;
21
+ attempts: z.ZodArray<z.ZodObject<{
22
+ id: z.ZodString;
23
+ outcome: z.ZodString;
24
+ rolledBack: z.ZodBoolean;
25
+ before: z.ZodNullable<z.ZodObject<{
26
+ testsPassed: z.ZodNumber;
27
+ testsFailed: z.ZodNumber;
28
+ mutantsKilled: z.ZodNumber;
29
+ mutantsSurvived: z.ZodNumber;
30
+ claimStatuses: z.ZodRecord<z.ZodString, z.ZodString>;
31
+ }, z.core.$strip>>;
32
+ after: z.ZodNullable<z.ZodObject<{
33
+ testsPassed: z.ZodNumber;
34
+ testsFailed: z.ZodNumber;
35
+ mutantsKilled: z.ZodNumber;
36
+ mutantsSurvived: z.ZodNumber;
37
+ claimStatuses: z.ZodRecord<z.ZodString, z.ZodString>;
38
+ }, z.core.$strip>>;
39
+ reasons: z.ZodArray<z.ZodString>;
40
+ }, z.core.$strip>>;
41
+ }, z.core.$strip>;
42
+ export type ReportImprovement = z.infer<typeof Improvement>;
43
+ export declare const ReportInput: z.ZodObject<{
44
+ meta: z.ZodObject<{
45
+ schemaVersion: z.ZodString;
46
+ runId: z.ZodString;
47
+ createdAt: z.ZodISODateTime;
48
+ toolVersion: z.ZodString;
49
+ gitCommit: z.ZodNullable<z.ZodString>;
50
+ configHash: z.ZodString;
51
+ sourceHash: z.ZodString;
52
+ }, z.core.$strip>;
53
+ run: z.ZodObject<{
54
+ id: z.ZodString;
55
+ command: z.ZodString;
56
+ args: z.ZodArray<z.ZodString>;
57
+ profile: z.ZodOptional<z.ZodEnum<{
58
+ quick: "quick";
59
+ standard: "standard";
60
+ deep: "deep";
61
+ }>>;
62
+ scope: z.ZodObject<{
63
+ root: z.ZodString;
64
+ since: z.ZodOptional<z.ZodString>;
65
+ paths: z.ZodArray<z.ZodString>;
66
+ }, z.core.$strip>;
67
+ options: z.ZodOptional<z.ZodObject<{
68
+ includeProposed: z.ZodBoolean;
69
+ propertyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
70
+ formalEngine: z.ZodOptional<z.ZodEnum<{
71
+ z3: "z3";
72
+ lean: "lean";
73
+ }>>;
74
+ sources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
75
+ local: "local";
76
+ github: "github";
77
+ web: "web";
78
+ }>>>;
79
+ web: z.ZodOptional<z.ZodObject<{
80
+ allowDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
81
+ maxPages: z.ZodOptional<z.ZodNumber>;
82
+ }, z.core.$strip>>;
83
+ mutationReport: z.ZodOptional<z.ZodString>;
84
+ killMatrix: z.ZodOptional<z.ZodBoolean>;
85
+ offline: z.ZodBoolean;
86
+ }, z.core.$strip>>;
87
+ startedAt: z.ZodISODateTime;
88
+ finishedAt: z.ZodOptional<z.ZodISODateTime>;
89
+ status: z.ZodEnum<{
90
+ error: "error";
91
+ succeeded: "succeeded";
92
+ failed: "failed";
93
+ partial: "partial";
94
+ skipped: "skipped";
95
+ unsupported: "unsupported";
96
+ timeout: "timeout";
97
+ cancelled: "cancelled";
98
+ }>;
99
+ exitCode: z.ZodOptional<z.ZodNumber>;
100
+ verdict: z.ZodOptional<z.ZodEnum<{
101
+ pass: "pass";
102
+ pass_with_warnings: "pass_with_warnings";
103
+ policy_failure: "policy_failure";
104
+ tool_error: "tool_error";
105
+ inconclusive: "inconclusive";
106
+ }>>;
107
+ policyReasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
108
+ stages: z.ZodArray<z.ZodObject<{
109
+ stage: z.ZodEnum<{
110
+ map: "map";
111
+ index: "index";
112
+ discover: "discover";
113
+ analyze: "analyze";
114
+ spec: "spec";
115
+ mutate: "mutate";
116
+ pbt: "pbt";
117
+ prove: "prove";
118
+ assess: "assess";
119
+ improve: "improve";
120
+ report: "report";
121
+ }>;
122
+ status: z.ZodEnum<{
123
+ error: "error";
124
+ succeeded: "succeeded";
125
+ failed: "failed";
126
+ partial: "partial";
127
+ skipped: "skipped";
128
+ unsupported: "unsupported";
129
+ timeout: "timeout";
130
+ cancelled: "cancelled";
131
+ }>;
132
+ startedAt: z.ZodISODateTime;
133
+ finishedAt: z.ZodISODateTime;
134
+ durationMs: z.ZodNumber;
135
+ artifacts: z.ZodArray<z.ZodString>;
136
+ messages: z.ZodArray<z.ZodString>;
137
+ usage: z.ZodObject<{
138
+ llmTokens: z.ZodNumber;
139
+ solverMs: z.ZodNumber;
140
+ mutants: z.ZodNumber;
141
+ testRuns: z.ZodNumber;
142
+ }, z.core.$strip>;
143
+ }, z.core.$strip>>;
144
+ capabilities: z.ZodArray<z.ZodObject<{
145
+ name: z.ZodEnum<{
146
+ node: "node";
147
+ git: "git";
148
+ package_manager: "package_manager";
149
+ typescript: "typescript";
150
+ vitest: "vitest";
151
+ mutator: "mutator";
152
+ fast_check: "fast_check";
153
+ z3: "z3";
154
+ lean: "lean";
155
+ llm: "llm";
156
+ network: "network";
157
+ sandbox: "sandbox";
158
+ }>;
159
+ state: z.ZodEnum<{
160
+ available: "available";
161
+ degraded: "degraded";
162
+ unavailable: "unavailable";
163
+ disabled: "disabled";
164
+ }>;
165
+ version: z.ZodOptional<z.ZodString>;
166
+ detail: z.ZodString;
167
+ affects: z.ZodArray<z.ZodString>;
168
+ }, z.core.$strip>>;
169
+ environment: z.ZodObject<{
170
+ os: z.ZodString;
171
+ arch: z.ZodString;
172
+ node: z.ZodString;
173
+ }, z.core.$strip>;
174
+ seeds: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
175
+ usage: z.ZodObject<{
176
+ llmTokens: z.ZodNumber;
177
+ solverMs: z.ZodNumber;
178
+ mutants: z.ZodNumber;
179
+ testRuns: z.ZodNumber;
180
+ }, z.core.$strip>;
181
+ replay: z.ZodString;
182
+ partial: z.ZodBoolean;
183
+ }, z.core.$strip>;
184
+ sources: z.ZodArray<z.ZodObject<{
185
+ id: z.ZodString;
186
+ kind: z.ZodEnum<{
187
+ git: "git";
188
+ code: "code";
189
+ web: "web";
190
+ human: "human";
191
+ standard: "standard";
192
+ readme: "readme";
193
+ docs: "docs";
194
+ test: "test";
195
+ issue: "issue";
196
+ pr: "pr";
197
+ runtime: "runtime";
198
+ }>;
199
+ locator: z.ZodString;
200
+ revision: z.ZodOptional<z.ZodString>;
201
+ range: z.ZodOptional<z.ZodObject<{
202
+ start: z.ZodNumber;
203
+ end: z.ZodNumber;
204
+ }, z.core.$strip>>;
205
+ capturedAt: z.ZodISODateTime;
206
+ contentHash: z.ZodString;
207
+ derivedFrom: z.ZodArray<z.ZodString>;
208
+ summary: z.ZodString;
209
+ trust: z.ZodLiteral<"untrusted_data">;
210
+ }, z.core.$strip>>;
211
+ statements: z.ZodArray<z.ZodObject<{
212
+ id: z.ZodString;
213
+ sourceId: z.ZodString;
214
+ range: z.ZodObject<{
215
+ start: z.ZodNumber;
216
+ end: z.ZodNumber;
217
+ }, z.core.$strip>;
218
+ quote: z.ZodString;
219
+ modality: z.ZodString;
220
+ flags: z.ZodArray<z.ZodString>;
221
+ }, z.core.$strip>>;
222
+ properties: z.ZodArray<z.ZodObject<{
223
+ id: z.ZodString;
224
+ version: z.ZodNumber;
225
+ description: z.ZodString;
226
+ template: z.ZodEnum<{
227
+ custom: "custom";
228
+ boundary: "boundary";
229
+ monotonicity: "monotonicity";
230
+ commutativity: "commutativity";
231
+ idempotence: "idempotence";
232
+ inverse: "inverse";
233
+ exception_condition: "exception_condition";
234
+ round_trip: "round_trip";
235
+ state_invariant: "state_invariant";
236
+ }>;
237
+ targetSymbols: z.ZodArray<z.ZodString>;
238
+ status: z.ZodEnum<{
239
+ proposed: "proposed";
240
+ reviewed: "reviewed";
241
+ accepted: "accepted";
242
+ rejected: "rejected";
243
+ conflicted: "conflicted";
244
+ superseded: "superseded";
245
+ }>;
246
+ origin: z.ZodEnum<{
247
+ normative: "normative";
248
+ inferred: "inferred";
249
+ observed: "observed";
250
+ human: "human";
251
+ }>;
252
+ sourceIds: z.ZodArray<z.ZodString>;
253
+ assumptions: z.ZodArray<z.ZodString>;
254
+ inputDomain: z.ZodRecord<z.ZodString, z.ZodUnknown>;
255
+ formalExpression: z.ZodOptional<z.ZodString>;
256
+ predicate: z.ZodOptional<z.ZodObject<{
257
+ param: z.ZodString;
258
+ operator: z.ZodEnum<{
259
+ "<": "<";
260
+ "<=": "<=";
261
+ ">": ">";
262
+ ">=": ">=";
263
+ "==": "==";
264
+ }>;
265
+ value: z.ZodString;
266
+ consequence: z.ZodString;
267
+ }, z.core.$strip>>;
268
+ statementIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
269
+ citations: z.ZodDefault<z.ZodArray<z.ZodString>>;
270
+ ir: z.ZodOptional<z.ZodObject<{
271
+ irVersion: z.ZodLiteral<1>;
272
+ params: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
273
+ name: z.ZodString;
274
+ sort: z.ZodLiteral<"int">;
275
+ domain: z.ZodObject<{
276
+ min: z.ZodString;
277
+ max: z.ZodString;
278
+ }, z.core.$strip>;
279
+ }, z.core.$strip>, z.ZodObject<{
280
+ name: z.ZodString;
281
+ sort: z.ZodLiteral<"bool">;
282
+ }, z.core.$strip>], "sort">>;
283
+ preconditions: z.ZodArray<z.ZodType<import("@under18dev/veritas-core").Expr, unknown, z.core.$ZodTypeInternals<import("@under18dev/veritas-core").Expr, unknown>>>;
284
+ body: z.ZodType<import("@under18dev/veritas-core").Expr, unknown, z.core.$ZodTypeInternals<import("@under18dev/veritas-core").Expr, unknown>>;
285
+ functions: z.ZodArray<z.ZodObject<{
286
+ name: z.ZodString;
287
+ symbol: z.ZodString;
288
+ params: z.ZodArray<z.ZodObject<{
289
+ name: z.ZodString;
290
+ sort: z.ZodEnum<{
291
+ int: "int";
292
+ bool: "bool";
293
+ }>;
294
+ }, z.core.$strip>>;
295
+ returns: z.ZodEnum<{
296
+ int: "int";
297
+ bool: "bool";
298
+ }>;
299
+ body: z.ZodNullable<z.ZodType<import("@under18dev/veritas-core").Expr, unknown, z.core.$ZodTypeInternals<import("@under18dev/veritas-core").Expr, unknown>>>;
300
+ jsParams: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
301
+ kind: z.ZodLiteral<"scalar">;
302
+ name: z.ZodString;
303
+ param: z.ZodString;
304
+ }, z.core.$strip>, z.ZodObject<{
305
+ kind: z.ZodLiteral<"record">;
306
+ name: z.ZodString;
307
+ fields: z.ZodArray<z.ZodObject<{
308
+ key: z.ZodString;
309
+ param: z.ZodString;
310
+ }, z.core.$strip>>;
311
+ }, z.core.$strip>, z.ZodObject<{
312
+ kind: z.ZodLiteral<"array">;
313
+ name: z.ZodString;
314
+ length: z.ZodString;
315
+ elements: z.ZodArray<z.ZodString>;
316
+ }, z.core.$strip>], "kind">>>;
317
+ outOfBounds: z.ZodOptional<z.ZodArray<z.ZodType<import("@under18dev/veritas-core").Expr, unknown, z.core.$ZodTypeInternals<import("@under18dev/veritas-core").Expr, unknown>>>>;
318
+ }, z.core.$strip>>;
319
+ }, z.core.$strip>>;
320
+ conflictsWith: z.ZodArray<z.ZodString>;
321
+ supersededBy: z.ZodOptional<z.ZodString>;
322
+ confidence: z.ZodObject<{
323
+ sourceQuality: z.ZodEnum<{
324
+ unknown: "unknown";
325
+ primary: "primary";
326
+ secondary: "secondary";
327
+ derived: "derived";
328
+ implementation: "implementation";
329
+ }>;
330
+ agreement: z.ZodEnum<{
331
+ unknown: "unknown";
332
+ agree: "agree";
333
+ disagree: "disagree";
334
+ mixed: "mixed";
335
+ single_source: "single_source";
336
+ }>;
337
+ implementationAlignment: z.ZodEnum<{
338
+ unknown: "unknown";
339
+ agree: "agree";
340
+ disagree: "disagree";
341
+ }>;
342
+ independence: z.ZodEnum<{
343
+ unknown: "unknown";
344
+ derived: "derived";
345
+ independent: "independent";
346
+ circular: "circular";
347
+ }>;
348
+ freshness: z.ZodEnum<{
349
+ unknown: "unknown";
350
+ current: "current";
351
+ stale: "stale";
352
+ }>;
353
+ }, z.core.$strip>;
354
+ implementationAgreement: z.ZodEnum<{
355
+ unknown: "unknown";
356
+ agree: "agree";
357
+ disagree: "disagree";
358
+ }>;
359
+ experimental: z.ZodBoolean;
360
+ reviewedBy: z.ZodOptional<z.ZodString>;
361
+ }, z.core.$strip>>;
362
+ conflicts: z.ZodArray<z.ZodObject<{
363
+ id: z.ZodString;
364
+ symbol: z.ZodString;
365
+ param: z.ZodString;
366
+ propertyIds: z.ZodArray<z.ZodString>;
367
+ preferredPropertyId: z.ZodNullable<z.ZodString>;
368
+ rationale: z.ZodArray<z.ZodString>;
369
+ }, z.core.$strip>>;
370
+ tests: z.ZodArray<z.ZodObject<{
371
+ id: z.ZodString;
372
+ file: z.ZodString;
373
+ name: z.ZodString;
374
+ suitePath: z.ZodArray<z.ZodString>;
375
+ location: z.ZodObject<{
376
+ file: z.ZodString;
377
+ range: z.ZodOptional<z.ZodObject<{
378
+ start: z.ZodNumber;
379
+ end: z.ZodNumber;
380
+ }, z.core.$strip>>;
381
+ }, z.core.$strip>;
382
+ modifiers: z.ZodArray<z.ZodEnum<{
383
+ skip: "skip";
384
+ only: "only";
385
+ todo: "todo";
386
+ concurrent: "concurrent";
387
+ each: "each";
388
+ }>>;
389
+ assertionCount: z.ZodNumber;
390
+ calledSymbols: z.ZodArray<z.ZodString>;
391
+ targetCalls: z.ZodArray<z.ZodObject<{
392
+ symbol: z.ZodString;
393
+ args: z.ZodArray<z.ZodNullable<z.ZodString>>;
394
+ asserted: z.ZodBoolean;
395
+ location: z.ZodObject<{
396
+ file: z.ZodString;
397
+ range: z.ZodOptional<z.ZodObject<{
398
+ start: z.ZodNumber;
399
+ end: z.ZodNumber;
400
+ }, z.core.$strip>>;
401
+ }, z.core.$strip>;
402
+ }, z.core.$strip>>;
403
+ usesMocks: z.ZodBoolean;
404
+ usesSnapshots: z.ZodBoolean;
405
+ nondeterminism: z.ZodArray<z.ZodString>;
406
+ suspicions: z.ZodArray<z.ZodEnum<{
407
+ no_assertion: "no_assertion";
408
+ tautological_assertion: "tautological_assertion";
409
+ target_not_called: "target_not_called";
410
+ unconditional_mock: "unconditional_mock";
411
+ unresolved_import: "unresolved_import";
412
+ opaque_call: "opaque_call";
413
+ }>>;
414
+ granularity: z.ZodEnum<{
415
+ test: "test";
416
+ suite: "suite";
417
+ }>;
418
+ }, z.core.$strip>>;
419
+ edges: z.ZodArray<z.ZodObject<{
420
+ id: z.ZodString;
421
+ testId: z.ZodString;
422
+ symbol: z.ZodString;
423
+ propertyId: z.ZodNullable<z.ZodString>;
424
+ evidence: z.ZodArray<z.ZodObject<{
425
+ kind: z.ZodEnum<{
426
+ direct_assertion: "direct_assertion";
427
+ mutation_evidence: "mutation_evidence";
428
+ execution_trace: "execution_trace";
429
+ static_call: "static_call";
430
+ llm_hypothesis: "llm_hypothesis";
431
+ name_similarity: "name_similarity";
432
+ }>;
433
+ detail: z.ZodString;
434
+ artifactIds: z.ZodArray<z.ZodString>;
435
+ }, z.core.$strip>>;
436
+ }, z.core.$strip>>;
437
+ assessments: z.ZodArray<z.ZodObject<{
438
+ testId: z.ZodString;
439
+ propertyIds: z.ZodArray<z.ZodString>;
440
+ evidenceIds: z.ZodArray<z.ZodString>;
441
+ killedMutantIds: z.ZodArray<z.ZodString>;
442
+ survivedMutantIds: z.ZodArray<z.ZodString>;
443
+ formalClaimIds: z.ZodArray<z.ZodString>;
444
+ vector: z.ZodObject<{
445
+ specificationRelevance: z.ZodArray<z.ZodObject<{
446
+ propertyId: z.ZodString;
447
+ status: z.ZodString;
448
+ }, z.core.$strip>>;
449
+ assertionRelevance: z.ZodEnum<{
450
+ unknown: "unknown";
451
+ checks_result: "checks_result";
452
+ weak: "weak";
453
+ none: "none";
454
+ }>;
455
+ mutationDetection: z.ZodObject<{
456
+ killed: z.ZodArray<z.ZodString>;
457
+ survived: z.ZodArray<z.ZodString>;
458
+ other: z.ZodArray<z.ZodString>;
459
+ }, z.core.$strip>;
460
+ boundaryCoverage: z.ZodArray<z.ZodObject<{
461
+ boundary: z.ZodString;
462
+ exercised: z.ZodEnum<{
463
+ unknown: "unknown";
464
+ yes: "yes";
465
+ no: "no";
466
+ }>;
467
+ }, z.core.$strip>>;
468
+ formalEvidence: z.ZodArray<z.ZodString>;
469
+ sourceConfidence: z.ZodArray<z.ZodString>;
470
+ unknowns: z.ZodArray<z.ZodString>;
471
+ }, z.core.$strip>;
472
+ outcome: z.ZodEnum<{
473
+ meaningful_with_evidence: "meaningful_with_evidence";
474
+ weak_or_incomplete: "weak_or_incomplete";
475
+ tautological_or_disconnected: "tautological_or_disconnected";
476
+ spec_conflict: "spec_conflict";
477
+ inconclusive: "inconclusive";
478
+ }>;
479
+ limitations: z.ZodArray<z.ZodString>;
480
+ rationale: z.ZodArray<z.ZodString>;
481
+ }, z.core.$strip>>;
482
+ mutants: z.ZodArray<z.ZodObject<{
483
+ id: z.ZodString;
484
+ backendKey: z.ZodString;
485
+ location: z.ZodObject<{
486
+ file: z.ZodString;
487
+ range: z.ZodOptional<z.ZodObject<{
488
+ start: z.ZodNumber;
489
+ end: z.ZodNumber;
490
+ }, z.core.$strip>>;
491
+ }, z.core.$strip>;
492
+ operator: z.ZodString;
493
+ original: z.ZodString;
494
+ replacement: z.ZodString;
495
+ status: z.ZodEnum<{
496
+ unknown: "unknown";
497
+ timeout: "timeout";
498
+ killed: "killed";
499
+ survived: "survived";
500
+ compile_error: "compile_error";
501
+ runtime_error: "runtime_error";
502
+ ignored: "ignored";
503
+ no_coverage: "no_coverage";
504
+ pending: "pending";
505
+ suspected_equivalent: "suspected_equivalent";
506
+ equivalent_proven: "equivalent_proven";
507
+ }>;
508
+ statusReason: z.ZodOptional<z.ZodString>;
509
+ killedBy: z.ZodArray<z.ZodString>;
510
+ coveredBy: z.ZodArray<z.ZodString>;
511
+ propertyIds: z.ZodArray<z.ZodString>;
512
+ relevance: z.ZodEnum<{
513
+ unknown: "unknown";
514
+ spec_relevant: "spec_relevant";
515
+ unrelated: "unrelated";
516
+ }>;
517
+ durationMs: z.ZodOptional<z.ZodNumber>;
518
+ reproduction: z.ZodString;
519
+ }, z.core.$strip>>;
520
+ claims: z.ZodArray<z.ZodObject<{
521
+ id: z.ZodString;
522
+ propertyId: z.ZodString;
523
+ kind: z.ZodEnum<{
524
+ conformance: "conformance";
525
+ distinguishability: "distinguishability";
526
+ bounded_equivalence: "bounded_equivalence";
527
+ property_detection: "property_detection";
528
+ }>;
529
+ status: z.ZodEnum<{
530
+ proven_within_model: "proven_within_model";
531
+ counterexample_found: "counterexample_found";
532
+ unknown: "unknown";
533
+ unsupported: "unsupported";
534
+ timeout: "timeout";
535
+ semantic_mismatch: "semantic_mismatch";
536
+ error: "error";
537
+ }>;
538
+ engine: z.ZodString;
539
+ engineVersion: z.ZodString;
540
+ assurance: z.ZodEnum<{
541
+ none: "none";
542
+ smt_bounded: "smt_bounded";
543
+ kernel_checked: "kernel_checked";
544
+ }>;
545
+ modelId: z.ZodString;
546
+ assumptions: z.ZodArray<z.ZodString>;
547
+ scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
548
+ semanticGaps: z.ZodArray<z.ZodString>;
549
+ solverInputArtifact: z.ZodOptional<z.ZodString>;
550
+ solverOutputArtifact: z.ZodOptional<z.ZodString>;
551
+ counterexample: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
552
+ reproduction: z.ZodOptional<z.ZodString>;
553
+ semanticValidation: z.ZodEnum<{
554
+ confirmed: "confirmed";
555
+ mismatch: "mismatch";
556
+ not_attempted: "not_attempted";
557
+ }>;
558
+ durationMs: z.ZodNumber;
559
+ mutantId: z.ZodOptional<z.ZodString>;
560
+ }, z.core.$strip>>;
561
+ findings: z.ZodArray<z.ZodObject<{
562
+ id: z.ZodString;
563
+ kind: z.ZodEnum<{
564
+ spec_conflict: "spec_conflict";
565
+ spec_implementation_mismatch: "spec_implementation_mismatch";
566
+ test_gap: "test_gap";
567
+ tautological_test: "tautological_test";
568
+ survived_mutant: "survived_mutant";
569
+ counterexample: "counterexample";
570
+ spec_violation_candidate: "spec_violation_candidate";
571
+ unsupported_semantics: "unsupported_semantics";
572
+ stage_failure: "stage_failure";
573
+ }>;
574
+ title: z.ZodString;
575
+ severity: z.ZodEnum<{
576
+ critical: "critical";
577
+ high: "high";
578
+ medium: "medium";
579
+ low: "low";
580
+ info: "info";
581
+ }>;
582
+ certainty: z.ZodEnum<{
583
+ confirmed: "confirmed";
584
+ suspected: "suspected";
585
+ informational: "informational";
586
+ }>;
587
+ locations: z.ZodArray<z.ZodObject<{
588
+ file: z.ZodString;
589
+ range: z.ZodOptional<z.ZodObject<{
590
+ start: z.ZodNumber;
591
+ end: z.ZodNumber;
592
+ }, z.core.$strip>>;
593
+ }, z.core.$strip>>;
594
+ propertyIds: z.ZodArray<z.ZodString>;
595
+ sourceIds: z.ZodArray<z.ZodString>;
596
+ testIds: z.ZodArray<z.ZodString>;
597
+ mutantIds: z.ZodArray<z.ZodString>;
598
+ claimIds: z.ZodArray<z.ZodString>;
599
+ explanation: z.ZodArray<z.ZodString>;
600
+ nextActions: z.ZodArray<z.ZodString>;
601
+ }, z.core.$strip>>;
602
+ improvements: z.ZodDefault<z.ZodArray<z.ZodObject<{
603
+ planId: z.ZodString;
604
+ outcome: z.ZodString;
605
+ goal: z.ZodNullable<z.ZodString>;
606
+ proposedTests: z.ZodArray<z.ZodString>;
607
+ patchPreview: z.ZodString;
608
+ reasons: z.ZodArray<z.ZodString>;
609
+ attempts: z.ZodArray<z.ZodObject<{
610
+ id: z.ZodString;
611
+ outcome: z.ZodString;
612
+ rolledBack: z.ZodBoolean;
613
+ before: z.ZodNullable<z.ZodObject<{
614
+ testsPassed: z.ZodNumber;
615
+ testsFailed: z.ZodNumber;
616
+ mutantsKilled: z.ZodNumber;
617
+ mutantsSurvived: z.ZodNumber;
618
+ claimStatuses: z.ZodRecord<z.ZodString, z.ZodString>;
619
+ }, z.core.$strip>>;
620
+ after: z.ZodNullable<z.ZodObject<{
621
+ testsPassed: z.ZodNumber;
622
+ testsFailed: z.ZodNumber;
623
+ mutantsKilled: z.ZodNumber;
624
+ mutantsSurvived: z.ZodNumber;
625
+ claimStatuses: z.ZodRecord<z.ZodString, z.ZodString>;
626
+ }, z.core.$strip>>;
627
+ reasons: z.ZodArray<z.ZodString>;
628
+ }, z.core.$strip>>;
629
+ }, z.core.$strip>>>;
630
+ artifactBase: z.ZodString;
631
+ }, z.core.$strip>;
632
+ export type ReportInput = z.infer<typeof ReportInput>;
633
+ export type ReportStatement = z.infer<typeof Statement>;
634
+ export type SarifLog = {
635
+ version: '2.1.0';
636
+ $schema: string;
637
+ runs: Array<{
638
+ tool: {
639
+ driver: {
640
+ name: string;
641
+ version?: string;
642
+ rules: unknown[];
643
+ };
644
+ };
645
+ properties?: Record<string, unknown>;
646
+ results: unknown[];
647
+ }>;
648
+ };
649
+ export declare function renderText(input: ReportInput): string;
650
+ export declare function renderJson(input: ReportInput): string;
651
+ export declare function reportJsonSchema(): object;
652
+ export declare function renderMarkdown(input: ReportInput): string;
653
+ /**
654
+ * A link target for a run artifact, or null when either part is not a plain relative path (see
655
+ * `isPlainRelativePath`): URL schemes, absolute paths, backslashes and `.`/`..` segments could point anywhere.
656
+ * The base may also be `.`.
657
+ */
658
+ export declare function safeArtifactHref(base: string, artifact: string): string | null;
659
+ export declare function renderHtml(input: ReportInput): string;
660
+ export declare function renderSarif(input: ReportInput): SarifLog;
661
+ export declare function validateSarif(log: SarifLog): {
662
+ valid: boolean;
663
+ errors: string[];
664
+ };
665
+ export declare function renderCiSummary(input: ReportInput, options?: {
666
+ artifactUrl?: string;
667
+ }): string;
668
+ export {};
669
+ //# sourceMappingURL=index.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAgB,CAAC,EAAE,MAAM,KAAK,CAAC;AAEtC,QAAA,MAAM,SAAS;;;;;;;;;;iBAOb,CAAC;AACH,mGAAmG;AACnG,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBf,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAU5D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC;QACV,IAAI,EAAE;YAAE,MAAM,EAAE;gBAAE,IAAI,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,OAAO,EAAE,CAAA;aAAE,CAAA;SAAE,CAAC;QACvE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,OAAO,EAAE,OAAO,EAAE,CAAC;KACpB,CAAC,CAAC;CACJ,CAAC;AAqMF,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAErD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAIrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAKzC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAWzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9E;AA6BD,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAmErD;AAgBD,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,CAqCxD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA2BjF;AAOD,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,CAQlG"}