tslaws 0.5.1 → 0.6.1

package/dist/check.js

@@ -10,6 +10,7 @@ import { proveLaw } from "./smt.js";
 import { decodeExample, loadExamples, regressionMessage, saveExample } from "./regressions.js";
 import { closeBrowser, runBrowserLaw } from "./browser.js";
 import { ensureServer, importsBoth, lawMode, runE2eLaw, stopServer } from "./e2e.js";
+import { declarationOf, exercisesOf, markFailing, Sources } from "./exercises.js";
 /** The `@tslaws-exempt` functions of the project, for `tslaws accept` to record. */
 export function exemptionsOf(options) {
     const covered = coverFiles(options.cwd, readConfig(options.cwd).cover ?? []);
@@ -28,8 +29,27 @@ export async function check(options, enforceLock) {
     const laws = readManifest(options.compiler, options.files, options.cwd);
     const results = [];
     const blocked = new Set();
+    const sources = new Sources(options.cwd);
+    // What a law reaches is syntactic and cheap; a project that cannot be read this way just has no locations.
+    const exercisesFor = (law) => {
+        try {
+            return exercisesOf(sources, law);
+        }
+        catch {
+            return [];
+        }
+    };
     const add = (law, status, method, extra = {}) => {
-        const result = { file: law.file, name: law.name, line: law.line, status, method, ...extra };
+        const exercises = status === 'tampered' ? [] : (extra.exercises ?? exercisesFor(law));
+        const result = {
+            file: law.file,
+            name: law.name,
+            line: law.line,
+            status,
+            method,
+            ...extra,
+            ...(exercises.length > 0 ? { exercises } : {}),
+        };
         results.push(result);
         blocked.add(lawKey(law.file, law.name));
         options.onEvent?.({ type: 'result', result });
@@ -164,6 +184,7 @@ export async function check(options, enforceLock) {
                     ? 'returned false'
                     : `threw: ${details.message}`;
                 add(law, 'failed', method, {
+                    exercises: markFailing(exercisesFor(law), details.stack, built.outDir),
                     runs: details.numRuns,
                     seed: details.seed,
                     counterexample: details.counterexample,
@@ -240,7 +261,7 @@ export async function check(options, enforceLock) {
             results.push({
                 file,
                 name,
-                line: 0,
+                line: declarationOf(sources, file, name)?.line ?? 0,
                 status: 'uncovered',
                 method: 'coverage',
                 message: 'no law reaches this exported function; add a law, or a person can mark it @tslaws-exempt and accept',

package/dist/cli.js

@@ -18,7 +18,7 @@ import { serveUi } from "./ui.js";
 import { acceptGate, defaultDuration, describeGrants, fileHash, grantFor, logDelegatedAccept, parseDuration, personOnly, revokeFor, } from "./delegation.js";
 import { writeLock } from "./lock.js";
 const usage = `tslaws init [--force]       scaffold tslaws.json, .gitignore, AGENTS.md, Claude Code hooks and a starter law (never writes the lock)
-tslaws check [files...] [--reporter text|json|junit|github] [--json] [--summary] [--watch] [--runs N] [--seed N] [--no-prove] [--no-regressions] [--bound N] [--proof-timeout MS] [--property-timeout MS] [--proposed] [--compiler PATH] [--browser chromium|firefox|webkit]
+tslaws check [files...] [--reporter text|json|junit|github|ndjson] [--law NAME[,NAME]] [--json] [--summary] [--watch] [--runs N] [--seed N] [--no-prove] [--no-regressions] [--bound N] [--proof-timeout MS] [--property-timeout MS] [--proposed] [--compiler PATH] [--browser chromium|firefox|webkit]
 tslaws ui [files...] [--port N] [--no-open] [--tab]   open a dashboard of the laws in its own desktop window (--tab: a browser tab): tree, filters, search, source, live reruns on save
 tslaws mutate [files...] [--max N] [--seed N] [--runs N] [--bound N] [--proof-timeout MS] [--property-timeout MS] [--browser ENGINE] [--json]   mutation-test the laws: mutate covered code, report mutants no law kills
 tslaws regressions [list|clear]   show or delete the stored counterexamples (.tslaws/regressions); check replays them first, --no-regressions skips them
@@ -32,7 +32,8 @@ tslaws mcp [--compiler PATH]   serve check, check_proposed, explain and propose
 Without files, every *.laws.ts under the current directory is checked (*.proposed.laws.ts only with --proposed).
 Exit status is 0 only when every law is proved, bounded or tested and nothing is open, failed, uncovered or tampered with.
   --json      machine-readable report; each result carries a hint with the next action (same as --reporter json)
-  --reporter  text (default), json, junit (JUnit XML) or github (workflow annotations; appends a table to $GITHUB_STEP_SUMMARY)
+  --reporter  text (default), json, junit (JUnit XML), github (workflow annotations; appends a table to $GITHUB_STEP_SUMMARY) or ndjson (one JSON event per line as the check proceeds, then the report; for editors)
+  --law       check only the laws with these names (comma-separated), in the files chosen
   --summary   one line per non-passing law, then the totals line
   --watch     rerun the check when a .ts file under the current directory changes (Ctrl+C exits)
   --force     init: overwrite tslaws.json and replace the AGENTS.md section`;
@@ -68,6 +69,7 @@ function parse(args) {
         'browser',
         'port',
         'reporter',
+        'law',
         'max',
         'for',
         'root',
@@ -136,6 +138,9 @@ function render(report, flags) {
     if (reporter === 'json') {
         return `${JSON.stringify({ ...report, results: report.results.map((r) => ({ ...r, hint: hintFor(r) })) }, null, 2)}\n`;
     }
+    if (reporter === 'ndjson') {
+        return `${JSON.stringify({ type: 'report', ...report, results: report.results.map((r) => ({ ...r, hint: hintFor(r) })) })}\n`;
+    }
     let text = '';
     if (report.compileDiagnostics !== '')
         text += `${report.compileDiagnostics}\n\n`;
@@ -162,6 +167,7 @@ function options(cwd, flags, chosen) {
         lockFile: join(cwd, 'tsc-laws.lock'),
         noProve: flags.has('no-prove'),
         noRegressions: flags.has('no-regressions'),
+        only: typeof flags.get('law') === 'string' ? String(flags.get('law')).split(',').filter(Boolean) : undefined,
         bound: settings.bound,
         proofTimeoutMs: settings.proofTimeoutMs,
         propertyTimeoutMs: settings.propertyTimeoutMs,
@@ -183,7 +189,15 @@ async function runCheck(cwd, flags, files) {
         process.stderr.write('no laws files found (looking for *.laws.ts)\n');
         return 1;
     }
-    const report = await check(options(cwd, flags, chosen), !flags.has('proposed'));
+    // `--reporter ndjson` streams one JSON event per line as the check proceeds, then the report, so an editor can show progress.
+    const stream = flags.get('reporter') === 'ndjson';
+    const onEvent = stream
+        ? (event) => {
+            if (event.type !== 'frame')
+                process.stdout.write(`${JSON.stringify(event)}\n`);
+        }
+        : undefined;
+    const report = await check({ ...options(cwd, flags, chosen), onEvent }, !flags.has('proposed'));
     process.stdout.write(render(report, flags));
     return report.ok ? 0 : 1;
 }

package/dist/exercises.d.ts

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import type { ManifestLaw } from './types.ts';
+/** A range in a project file: lines and columns are 1-based, the end is exclusive. `file` is relative to the project. */
+export interface SourceSpan {
+    file: string;
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}
+export interface Exercised {
+    name: string;
+    /** The function's name where it is declared. */
+    declaration: SourceSpan;
+    /** The first reference to it in the law itself; absent for a function the law reaches only through others. */
+    call?: SourceSpan;
+    /** The failure came from this function: the stack of the error the law threw names it. */
+    failing?: true;
+}
+interface Binding {
+    /** The module the local name comes from, and the name it has there (`*` for a namespace import). */
+    module: string;
+    imported: string;
+}
+interface Declared {
+    name: string;
+    nameNode: ts.Node;
+    body: ts.Node;
+}
+interface Module {
+    file: string;
+    text: string;
+    source: ts.SourceFile;
+    nodes: Map<string, Declared>;
+    imports: Map<string, Binding>;
+    /** `export { local as exported }` of this module and `export { a as b } from './m'`. */
+    exports: Map<string, Binding | string>;
+    stars: string[];
+}
+/** Reads and indexes project modules once per check. */
+export declare class Sources {
+    private readonly modules;
+    readonly cwd: string;
+    constructor(cwd: string);
+    /** The module at project-relative `file`, or undefined when it is not a readable TypeScript source. */
+    module(file: string): Module | undefined;
+    /** The project file a specifier names, or undefined for a package, a declaration file or a path outside the project. */
+    private resolveImport;
+    private index;
+    /** The declaration `name` exports from `file`, following re-exports. */
+    find(file: string, name: string, depth?: number): {
+        module: Module;
+        node: Declared;
+    } | undefined;
+}
+/** The functions `law` reaches: the ones it names first, in the order it names them, then those they use. */
+export declare function exercisesOf(sources: Sources, law: ManifestLaw): Exercised[];
+/** The stack frames of `stack` that run project code: `[function, ...]` innermost first. */
+export declare function frameFunctions(stack: string, outDir: string): string[];
+/** Marks the function an error's stack names: the innermost project frame that is one of the law's functions. */
+export declare function markFailing(exercised: Exercised[], stack: string | undefined, outDir: string): Exercised[];
+/** The declaration of `name` in project `file`, for a result that names a function but not where it is. */
+export declare function declarationOf(sources: Sources, file: string, name: string): SourceSpan | undefined;
+export {};

package/dist/exercises.js

@@ -0,0 +1,284 @@
+// Which project functions a law exercises, and where they are: the declaration of each (its name) and, for a function the
+// law names itself, the reference in the law. An editor shows a failing law on both ends with this. It is a syntactic
+// walk over the sources, the same reach the coverage rule uses: calls and references to functions declared at the top of
+// a project module, followed through imports and re-exports, and through the functions those functions use.
+import { existsSync, readFileSync } from 'node:fs';
+import { relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+const resolution = {
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    module: ts.ModuleKind.ESNext,
+    allowImportingTsExtensions: true,
+    allowJs: false,
+};
+const ownSource = /\.(ts|tsx|mts|cts)$/;
+/** Reads and indexes project modules once per check. */
+export class Sources {
+    modules = new Map();
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    /** The module at project-relative `file`, or undefined when it is not a readable TypeScript source. */
+    module(file) {
+        if (this.modules.has(file))
+            return this.modules.get(file);
+        const full = resolve(this.cwd, file);
+        let module;
+        if (ownSource.test(file) && !file.endsWith('.d.ts') && existsSync(full)) {
+            const text = readFileSync(full, 'utf8');
+            module = this.index(file, text);
+        }
+        this.modules.set(file, module);
+        return module;
+    }
+    /** The project file a specifier names, or undefined for a package, a declaration file or a path outside the project. */
+    resolveImport(specifier, from) {
+        const found = ts.resolveModuleName(specifier, resolve(this.cwd, from), resolution, ts.sys).resolvedModule;
+        if (found === undefined || found.isExternalLibraryImport === true)
+            return undefined;
+        const file = relative(this.cwd, found.resolvedFileName).split(sep).join('/');
+        if (file.startsWith('..') || file.split('/').includes('node_modules'))
+            return undefined;
+        return ownSource.test(file) && !file.endsWith('.d.ts') ? file : undefined;
+    }
+    index(file, text) {
+        const source = ts.createSourceFile(file, text, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS);
+        const module = { file, text, source, nodes: new Map(), imports: new Map(), exports: new Map(), stars: [] };
+        const declare = (name, nameNode, body) => {
+            module.nodes.set(name, { name, nameNode, body });
+        };
+        /** The `default` keyword of a declaration, to point at when the function has no name. */
+        const defaultKeyword = (node) => node.getChildren(source).find((c) => c.kind === ts.SyntaxKind.DefaultKeyword) ??
+            (ts.canHaveModifiers(node)
+                ? ts.getModifiers(node)?.find((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
+                : undefined) ??
+            node;
+        const isDefault = (node) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+        for (const statement of source.statements) {
+            if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+                const target = this.resolveImport(statement.moduleSpecifier.text, file);
+                const clause = statement.importClause;
+                if (target === undefined || clause === undefined)
+                    continue;
+                if (clause.name !== undefined)
+                    module.imports.set(clause.name.text, { module: target, imported: 'default' });
+                const bindings = clause.namedBindings;
+                if (bindings !== undefined && ts.isNamespaceImport(bindings))
+                    module.imports.set(bindings.name.text, { module: target, imported: '*' });
+                else if (bindings !== undefined)
+                    for (const element of bindings.elements)
+                        module.imports.set(element.name.text, {
+                            module: target,
+                            imported: (element.propertyName ?? element.name).text,
+                        });
+            }
+            else if (ts.isExportDeclaration(statement)) {
+                const target = statement.moduleSpecifier !== undefined && ts.isStringLiteral(statement.moduleSpecifier)
+                    ? this.resolveImport(statement.moduleSpecifier.text, file)
+                    : undefined;
+                const clause = statement.exportClause;
+                if (clause === undefined || ts.isNamespaceExport(clause)) {
+                    if (target !== undefined && clause === undefined)
+                        module.stars.push(target);
+                }
+                else
+                    for (const element of clause.elements)
+                        module.exports.set(element.name.text, target === undefined
+                            ? (element.propertyName ?? element.name).text
+                            : { module: target, imported: (element.propertyName ?? element.name).text });
+            }
+            else if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) {
+                if (statement.name !== undefined)
+                    declare(statement.name.text, statement.name, statement);
+                if (isDefault(statement))
+                    declare('default', statement.name ?? defaultKeyword(statement), statement);
+            }
+            else if (ts.isExportAssignment(statement)) {
+                // `export default helper;` and `export = helper;` name a function declared elsewhere; `export default () => ...` is one.
+                const value = statement.expression;
+                if (ts.isIdentifier(value))
+                    module.exports.set('default', value.text);
+                else if (ts.isArrowFunction(value) || ts.isFunctionExpression(value) || ts.isClassExpression(value))
+                    declare('default', defaultKeyword(statement), value);
+            }
+            else if (ts.isVariableStatement(statement)) {
+                for (const declaration of statement.declarationList.declarations) {
+                    const init = declaration.initializer;
+                    if (ts.isIdentifier(declaration.name) &&
+                        init !== undefined &&
+                        (ts.isArrowFunction(init) || ts.isFunctionExpression(init) || ts.isClassExpression(init)))
+                        declare(declaration.name.text, declaration.name, init);
+                }
+            }
+        }
+        return module;
+    }
+    /** The declaration `name` exports from `file`, following re-exports. */
+    find(file, name, depth = 0) {
+        const module = this.module(file);
+        if (module === undefined || depth > 8)
+            return undefined;
+        const direct = module.nodes.get(name);
+        if (direct !== undefined)
+            return { module, node: direct };
+        const exported = module.exports.get(name);
+        if (typeof exported === 'string') {
+            const local = exported === name ? undefined : this.find(file, exported, depth + 1);
+            if (local !== undefined)
+                return local;
+            // `import { f } from './m'; export default f;` re-exports an imported function.
+            const binding = module.imports.get(exported);
+            return binding === undefined || binding.imported === '*'
+                ? undefined
+                : this.find(binding.module, binding.imported, depth + 1);
+        }
+        if (exported !== undefined)
+            return this.find(exported.module, exported.imported, depth + 1);
+        for (const star of module.stars) {
+            const hit = this.find(star, name, depth + 1);
+            if (hit !== undefined)
+                return hit;
+        }
+        return undefined;
+    }
+}
+function spanOf(module, node, start = node.getStart(module.source), end = node.getEnd()) {
+    const from = module.source.getLineAndCharacterOfPosition(start);
+    const to = module.source.getLineAndCharacterOfPosition(end);
+    return {
+        file: module.file,
+        line: from.line + 1,
+        column: from.character + 1,
+        endLine: to.line + 1,
+        endColumn: to.character + 1,
+    };
+}
+/** The law's own text parsed as TypeScript, with a way back from positions in it to the law's file. */
+function parseLaw(law, module) {
+    // A law is `name(params) { ... }` or `name(params) => expression;`: the first is a function, the second an arrow.
+    const arrow = law.body.startsWith('=>');
+    const prefix = arrow ? `const ${law.name} = ` : 'function ';
+    const wrapped = arrow ? `${prefix}${law.text.slice(law.name.length)}` : `${prefix}${law.text}`;
+    // The law's text is exact in its file; the declaration line says which copy when a text repeats.
+    let lineStart = 0;
+    for (let line = 1; line < law.line; line += 1) {
+        const next = module.text.indexOf('\n', lineStart);
+        if (next < 0)
+            break;
+        lineStart = next + 1;
+    }
+    const at = module.text.indexOf(law.text, lineStart);
+    const found = at >= 0 ? at : module.text.indexOf(law.text);
+    if (found < 0)
+        return undefined;
+    const shift = arrow ? prefix.length - law.name.length : prefix.length;
+    return {
+        source: ts.createSourceFile(law.file, wrapped, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS),
+        offset: (pos) => found + pos - shift,
+    };
+}
+/** The functions `law` reaches: the ones it names first, in the order it names them, then those they use. */
+export function exercisesOf(sources, law) {
+    const lawModule = sources.module(law.file);
+    if (lawModule === undefined)
+        return [];
+    const parsed = parseLaw(law, lawModule);
+    if (parsed === undefined)
+        return [];
+    const lawParams = new Set(law.params);
+    const out = [];
+    const seen = new Set();
+    const queue = [];
+    const reach = (hit, call) => {
+        const id = `${hit.module.file}::${hit.node.nameNode.getStart(hit.module.source)}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        const name = hit.node.name === 'default' && ts.isIdentifier(hit.node.nameNode) ? hit.node.nameNode.text : hit.node.name;
+        out.push({ name, declaration: spanOf(hit.module, hit.node.nameNode), ...(call === undefined ? {} : { call }) });
+        queue.push(hit);
+    };
+    /** The function an identifier (or `namespace.name`) in `module` stands for. */
+    const resolveName = (module, node) => {
+        if (ts.isIdentifier(node)) {
+            const local = module.nodes.get(node.text);
+            if (local !== undefined)
+                return { module, node: local };
+            const binding = module.imports.get(node.text);
+            return binding === undefined || binding.imported === '*'
+                ? undefined
+                : sources.find(binding.module, binding.imported);
+        }
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+            const binding = module.imports.get(node.expression.text);
+            return binding?.imported === '*' ? sources.find(binding.module, node.name.text) : undefined;
+        }
+        return undefined;
+    };
+    const walk = (module, root, own, inLaw) => {
+        const visit = (node) => {
+            if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
+                const parent = node.parent;
+                const isMember = parent !== undefined && ts.isPropertyAccessExpression(parent) && parent.name === node;
+                const isBinding = parent !== undefined &&
+                    ((ts.isParameter(parent) && parent.name === node) ||
+                        (ts.isVariableDeclaration(parent) && parent.name === node) ||
+                        (ts.isPropertyAssignment(parent) && parent.name === node));
+                const wholeName = ts.isIdentifier(node) ? node.text : undefined;
+                if (!isMember && !isBinding && !(inLaw && wholeName !== undefined && lawParams.has(wholeName))) {
+                    const hit = resolveName(module, node);
+                    if (hit !== undefined && hit.node !== own) {
+                        const call = inLaw && parsed !== undefined
+                            ? spanOfLaw(lawModule, parsed.offset(node.getStart(root.getSourceFile())), parsed.offset(node.getEnd()))
+                            : undefined;
+                        reach(hit, call);
+                        if (ts.isPropertyAccessExpression(node))
+                            return;
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(root);
+    };
+    walk(lawModule, parsed.source, undefined, true);
+    for (let i = 0; i < queue.length && queue.length < 400; i += 1) {
+        const { module, node } = queue[i];
+        walk(module, node.body, node, false);
+    }
+    return out;
+}
+function spanOfLaw(module, start, end) {
+    return spanOf(module, module.source, start, end);
+}
+/** The stack frames of `stack` that run project code: `[function, ...]` innermost first. */
+export function frameFunctions(stack, outDir) {
+    const dir = outDir.split(sep).join('/').toLowerCase();
+    const names = [];
+    for (const line of stack.split('\n')) {
+        const frame = /^\s*at (?:async )?(?:(\S+) )?\(?(.+?):\d+:\d+\)?\s*$/.exec(line);
+        if (frame === null || frame[1] === undefined)
+            continue;
+        const file = frame[2]
+            .replaceAll('\\', '/')
+            .replace(/^file:\/\/\/?/, '')
+            .toLowerCase();
+        if (file.includes(dir))
+            names.push(frame[1].split('.').pop());
+    }
+    return names;
+}
+/** Marks the function an error's stack names: the innermost project frame that is one of the law's functions. */
+export function markFailing(exercised, stack, outDir) {
+    if (stack === undefined)
+        return exercised;
+    const names = frameFunctions(stack, outDir);
+    const hit = names.map((n) => exercised.find((e) => e.name === n)).find((e) => e !== undefined);
+    return hit === undefined ? exercised : exercised.map((e) => (e === hit ? { ...e, failing: true } : e));
+}
+/** The declaration of `name` in project `file`, for a result that names a function but not where it is. */
+export function declarationOf(sources, file, name) {
+    const hit = sources.find(file, name);
+    return hit === undefined ? undefined : spanOf(hit.module, hit.node.nameNode);
+}

package/dist/property.d.ts

@@ -26,6 +26,8 @@ export interface PropertyOutcome {
     /** Absent when the law failed because `assume` discarded nearly every input. */
     counterexample?: string;
     message?: string;
+    /** The stack of the error the law threw, to say which function threw. */
+    stack?: string;
     screenshot?: string;
     /** The counterexample in the regression corpus's encoding; absent when it cannot be stored. */
     encoded?: string;

package/dist/property.js

@@ -141,6 +141,7 @@ export function summarise(details, options) {
         seed: details.seed,
         counterexample: details.counterexample === null ? undefined : fc.stringify(details.counterexample),
         message,
+        stack: details.errorInstance instanceof Error ? details.errorInstance.stack : undefined,
     };
 }
 let worker;

package/dist/reporters.d.ts

@@ -1,6 +1,6 @@
 import type { CheckReport } from './check.ts';
-/** The values of `tslaws check --reporter`. `text` and `json` are rendered by the CLI itself. */
-export declare const reporterNames: readonly ["text", "json", "junit", "github"];
+/** The values of `tslaws check --reporter`. `text`, `json` and `ndjson` are rendered by the CLI itself. */
+export declare const reporterNames: readonly ["text", "json", "junit", "github", "ndjson"];
 export type ReporterName = (typeof reporterNames)[number];
 /** Escape text for XML, dropping characters XML 1.0 cannot carry at all. */
 export declare function escapeXml(text: string): string;

package/dist/reporters.js

@@ -1,7 +1,7 @@
 import { appendFileSync } from 'node:fs';
 import { hintFor } from "./hints.js";
-/** The values of `tslaws check --reporter`. `text` and `json` are rendered by the CLI itself. */
-export const reporterNames = ['text', 'json', 'junit', 'github'];
+/** The values of `tslaws check --reporter`. `text`, `json` and `ndjson` are rendered by the CLI itself. */
+export const reporterNames = ['text', 'json', 'junit', 'github', 'ndjson'];
 const passing = new Set(['proved', 'bounded', 'tested']);
 const isPassing = (result) => passing.has(result.status);
 /** Whether XML 1.0 can carry the code point at all. */

package/dist/types.d.ts

@@ -11,6 +11,7 @@ export interface ManifestLaw {
     text: string;
     problems: string[];
 }
+import type { Exercised } from './exercises.ts';
 export interface LawResult {
     file: string;
     name: string;
@@ -24,6 +25,8 @@ export interface LawResult {
     message?: string;
     /** Project-relative path of a screenshot of the page at the counterexample (browser laws). */
     screenshot?: string;
+    /** The project functions the law reaches and where they are declared, for an editor to mark on both ends. */
+    exercises?: Exercised[];
 }
 export interface CheckOptions {
     files: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tslaws",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Runs and checks `law` declarations compiled by tsc-laws: property tests, SMT proofs, tamper lock.",
   "bin": {
     "tslaws": "bin/tslaws.js"
@@ -71,11 +71,11 @@
     }
   },
   "optionalDependencies": {
-    "tslaws-compiler-darwin-arm64": "0.5.1",
-    "tslaws-compiler-darwin-x64": "0.5.1",
-    "tslaws-compiler-linux-arm64-gnu": "0.5.1",
-    "tslaws-compiler-linux-x64-gnu": "0.5.1",
-    "tslaws-compiler-win32-x64-msvc": "0.5.1"
+    "tslaws-compiler-darwin-arm64": "0.6.1",
+    "tslaws-compiler-darwin-x64": "0.6.1",
+    "tslaws-compiler-linux-arm64-gnu": "0.6.1",
+    "tslaws-compiler-linux-x64-gnu": "0.6.1",
+    "tslaws-compiler-win32-x64-msvc": "0.6.1"
   },
   "publishConfig": {
     "access": "public"