@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.7

package/dist/src/text/shell.js

@@ -0,0 +1,159 @@
+/**
+ * Shell command lines read as text, never run: the commands a line runs, the tokens the
+ * Contract splits a command into, and the words POSIX token recognition reads.
+ */
+/**
+ * The shell's list and pipeline operators, each of which ends one command. An `&` beside a
+ * redirection's `<` or `>` (`2>&1`, and bash's `&>log`) is part of the redirection.
+ */
+const COMMAND_OPERATORS = /&&|\|\||;|\||(?<![<>])&(?!>)/u;
+/** Where a command splits into tokens: white space and the operators the Contract names. */
+const TOKEN_SEPARATORS = /\s+|&&|\|\||;|\|/u;
+/** A text written inside one pair of quotes. */
+const QUOTED = /^(["'])(.*)\1$/su;
+/** The commands one line runs, the text between two of the shell's list and pipeline operators. */
+export function commandsOf(line) {
+    return line.split(COMMAND_OPERATORS);
+}
+/** One text with one pair of enclosing quotes removed. */
+export function unquoted(text) {
+    return text.replace(QUOTED, "$2");
+}
+/**
+ * Every token one script's command line holds, each with one pair of enclosing quotes
+ * removed. A token holding a wildcard is a pattern rather than a path, and names no
+ * entry point.
+ */
+export function scriptTokens(command) {
+    return command
+        .split(TOKEN_SEPARATORS)
+        .map(unquoted)
+        .filter((token) => token !== "" && !token.includes("*"));
+}
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+export function withoutComment(line) {
+    let quote = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line[at];
+        if (quote !== "") {
+            if (char === quote) {
+                quote = "";
+            }
+            else if (char === "\\" && quote === '"') {
+                at += 1;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === "\\") {
+            at += 1;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at);
+        }
+    }
+    return line;
+}
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
+const BLANK = /[ \t\r\f\v]/u;
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+export function shellWords(command) {
+    const words = [];
+    let word;
+    let computed = false;
+    const end = () => {
+        if (word !== undefined) {
+            words.push(computed ? undefined : word);
+        }
+        word = undefined;
+        computed = false;
+    };
+    for (let at = 0; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === "\\" && command.charAt(at + 1) === "\n") {
+            at += 1;
+        }
+        else if (BLANK.test(char)) {
+            end();
+        }
+        else if (OPERATOR.test(char)) {
+            end();
+            words.push(undefined);
+        }
+        else if (char === "#" && word === undefined) {
+            const newline = command.indexOf("\n", at);
+            at = newline < 0 ? command.length : newline - 1;
+        }
+        else if (char === "\\") {
+            at += 1;
+            word = (word ?? "") + command.charAt(at);
+        }
+        else if (char === "'" || char === '"') {
+            const close = closingQuote(command, at);
+            if (close < 0) {
+                word ??= "";
+                computed = true;
+                break;
+            }
+            const quoted = char === "'"
+                ? { text: command.slice(at + 1, close), computed: false }
+                : doubleQuoted(command.slice(at + 1, close));
+            word = (word ?? "") + quoted.text;
+            computed ||= quoted.computed;
+            at = close;
+        }
+        else {
+            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+            word = (word ?? "") + char;
+        }
+    }
+    end();
+    return words;
+}
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner) {
+    let text = "";
+    let computed = false;
+    for (let at = 0; at < inner.length; at += 1) {
+        const char = inner.charAt(at);
+        const next = inner.charAt(at + 1);
+        if (char === "\\" && next === "\n") {
+            at += 1;
+        }
+        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+            text += next;
+            at += 1;
+        }
+        else {
+            computed ||= char === "$" || char === "`";
+            text += char;
+        }
+    }
+    return { text, computed };
+}
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command, open) {
+    const quote = command.charAt(open);
+    for (let at = open + 1; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === quote) {
+            return at;
+        }
+        if (quote === '"' && char === "\\") {
+            at += 1;
+        }
+    }
+    return -1;
+}

package/dist/src/{yaml-document.js → text/yaml.js}

@@ -5,6 +5,7 @@
  * alias, a tag, a block scalar, a complex key or a second document, has no value here,
  * as a JSON document that does not parse has none.
  */
+import { isRecord } from "../json-document.js";
 /** A failure to read the document within the subset; it ends the whole reading. */
 class Unsupported extends Error {
 }
@@ -353,3 +354,40 @@ export function yamlDocument(text) {
         throw error;
     }
 }
+/** The key one line of the document's top-level mapping opens, or undefined where it opens none. */
+function topLevelKey(raw) {
+    const content = withoutComment(raw).trimEnd();
+    const end = /^\s/u.test(content) ? -1 : keyEnd(content);
+    if (end < 0) {
+        return undefined;
+    }
+    try {
+        const key = scalar(content.slice(0, end));
+        return typeof key === "object" && key !== null ? undefined : String(key);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The value of one key of a document's top-level block mapping, read from that key's lines
+ * alone, so a document whose other keys lie outside the subset still yields it. A key
+ * declared twice, or one whose own lines lie outside the subset, is refused.
+ */
+export function yamlKey(text, key) {
+    const lines = text.replace(/^\uFEFF/u, "").split(/\r?\n/u);
+    const starts = lines.flatMap((line, at) => (topLevelKey(line) === undefined ? [] : [at]));
+    const named = starts.filter((at) => topLevelKey(lines[at] ?? "") === key);
+    const [start] = named;
+    if (start === undefined) {
+        return { kind: "absent" };
+    }
+    if (named.length > 1) {
+        return { kind: "refused", reason: `the ${key} key is declared more than once` };
+    }
+    const end = starts.find((at) => at > start) ?? lines.length;
+    const value = yamlDocument(lines.slice(start, end).join("\n"));
+    return isRecord(value)
+        ? { kind: "value", value: value[key] }
+        : { kind: "refused", reason: `the value of ${key} is outside the YAML subset read here` };
+}

package/dist/src/type-errors.js

@@ -8,9 +8,11 @@
 import { isClassDeclaration, isFunctionLikeDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
 import { packageOfSpecifier } from "./dependencies.js";
 import { nodeKey } from "./inventory.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { isAnswered } from "./query.js";
 import { findWorkspace } from "./workspace.js";
+import { entriesOf } from "./fs/tree.js";
+import { INSTALLED_PACKAGES, MANIFEST, manifestAt } from "./fs/manifest.js";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND = new Set([2307, 2792]);
 /**
@@ -19,7 +21,6 @@ const MODULE_NOT_FOUND = new Set([2307, 2792]);
  * 5056), a file outside `rootDir` (6059), one a composite project does not list (6307).
  */
 const CONFIGURATION_LEVEL = new Set([5055, 5056, 6059, 6307]);
-const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
     "dependencies",
     "devDependencies",
@@ -85,54 +86,29 @@ function provided(host, path, fileOnly) {
     }
     const dir = dirnamePath(path);
     const stem = `${path.slice(dir.length + 1)}.`;
-    try {
-        return host
-            .readDirectory(dir)
-            .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
-    }
-    catch {
-        return false;
-    }
+    return entriesOf(host, dir).some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
 }
 /** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
 function declaringManifest(host, dir, targetRoot, name) {
-    for (let at = dir;; at = dirnamePath(at)) {
-        const path = joinPath(at, MANIFEST);
-        let manifest;
-        try {
-            manifest = JSON.parse(host.readFile(path));
-        }
-        catch {
-            manifest = undefined;
-        }
-        if (typeof manifest === "object" && manifest !== null) {
-            const sections = manifest;
-            for (const section of MANIFEST_SECTIONS) {
-                const declared = sections[section];
-                if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
-                    return path;
-                }
+    const chain = ancestors(dir, targetRoot);
+    // A directory outside the target root reads its own manifest alone.
+    for (const at of chain.length > 0 ? chain : [dir]) {
+        const manifest = manifestAt(host, at);
+        for (const section of MANIFEST_SECTIONS) {
+            const declared = manifest?.[section];
+            if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
+                return joinPath(at, MANIFEST);
             }
         }
-        // The target root is not below itself, so the walk stops after reading its manifest.
-        if (relativePath(targetRoot, at) === undefined) {
-            return undefined;
-        }
     }
+    return undefined;
 }
 /**
  * Whether a package is installed for an importer in `dir`: in the `node_modules` of
  * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
  */
 function installed(host, dir, name) {
-    for (let at = dir;; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
-            return true;
-        }
-        if (dirnamePath(at) === at) {
-            return false;
-        }
-    }
+    return ancestors(dir).some((at) => host.kindOf(joinPath(at, INSTALLED_PACKAGES, name)) === "directory");
 }
 /**
  * Why one import that the compiler cannot resolve names a module the project expects,

package/dist/src/unseen-loads.js

@@ -4,19 +4,12 @@
  * naming a directory below the calling file's. The files such a load runs are roots the
  * analysis does not see, so the configuration's roots are never complete.
  */
-import { isAsExpression, isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
-function unwrapped(node) {
-    let at = node;
-    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
-        at = at.expression;
-    }
-    return at;
-}
+import { unwrapped } from "./unwrap.js";
 /** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
 export function leadingLiteral(node) {
     const at = unwrapped(node);

package/dist/src/unwrap.js

@@ -0,0 +1,23 @@
+import { isAsExpression, isNonNullExpression, isParenthesizedExpression, isSatisfiesExpression, } from "@typescript/native/ast";
+/** The expression inside every pair of parentheses around `node`. */
+export function parenthesesRemoved(node) {
+    let at = node;
+    while (isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/**
+ * The expression inside every wrapper around `node` that changes no value it evaluates to:
+ * parentheses, `as` and `satisfies` assertions and the non-null assertion.
+ */
+export function unwrapped(node) {
+    let at = node;
+    while (isParenthesizedExpression(at) ||
+        isAsExpression(at) ||
+        isSatisfiesExpression(at) ||
+        isNonNullExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}

package/dist/src/verbs/analyze.js

@@ -6,7 +6,7 @@ import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
-import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
+import { buildReport, capFindings, sortFindings, } from "../report.js";
 import { reportRefusals } from "../report-schema.js";
 import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
@@ -14,6 +14,8 @@ import { parseTemplate, TemplateError } from "../reporters/template.js";
 import { resolve } from "../resolve.js";
 import { otherSchemeRows, rowReason, writeBaseline } from "../suppress-file.js";
 import {} from "./verb.js";
+import { bytewise } from "../text/compare.js";
+import { diagnose, LANGUAGE, message } from "../product.js";
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS = {
     plain: ["report", "baseline-write", "exit-code", "template"],
@@ -31,7 +33,7 @@ class ReportPathError extends Error {
 }
 /** The formats this analyzer renders, for a message that names them. */
 function formatNames() {
-    return [...RENDERINGS.keys()].sort().join(", ");
+    return [...RENDERINGS.keys()].sort(bytewise).join(", ");
 }
 /** The renderings one invocation writes: the ones it named, else the configuration's. */
 function formatsOf(named, configured) {
@@ -137,7 +139,7 @@ function templateOf(host, invoked, named, formats) {
         source = host.readFile(resolvePath(invoked, named));
     }
     catch (error) {
-        throw new ConfigError("malformed", "", `--template=${named}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new ConfigError("malformed", "", `--template=${named}: ${message(error)}`);
     }
     try {
         return parseTemplate(source);
@@ -186,7 +188,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         version = host.analyzerVersion();
     }
     catch (error) {
-        err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+        diagnose(err, message(error));
         return EXIT_FAILURE;
     }
     let report;
@@ -254,7 +256,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         if (!(error instanceof ReportPathError)) {
             throw error;
         }
-        err.write(`deadset-ts: ${error.message}\n`);
+        diagnose(err, error.message);
         return EXIT_FAILURE;
     }
     try {
@@ -281,30 +283,30 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         }
     }
     catch (error) {
-        err.write(`deadset-ts: ${error instanceof Error ? error.message : String(error)}\n`);
+        diagnose(err, message(error));
         return EXIT_FAILURE;
     }
     for (const note of partial) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     for (const line of [...unread, ...unfound]) {
-        err.write(`deadset-ts: ${line}\n`);
+        diagnose(err, line);
     }
     for (const warning of warnings) {
-        err.write(`deadset-ts: ${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}\n`);
+        diagnose(err, `${warning.path}:${String(warning.line)}: a <script> start tag that begins a line is not read as a block: ${warning.reason}`);
     }
     for (const skip of report.type_error_skips) {
-        err.write(`deadset-ts: ${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated\n`);
+        diagnose(err, `${skip.path}:${String(skip.line)}: ${skip.message}: the function or statement holding this type error is not evaluated`);
     }
     if (report.totals.pending > 0) {
-        err.write(`deadset-ts: ${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it\n`);
+        diagnose(err, `${counted(report.totals.pending, "pending finding")}: the report names a declared cross-language edge, and no merge has resolved it`);
     }
     if (report.totals.stale_suppressions > 0) {
-        err.write(`deadset-ts: ${counted(report.totals.stale_suppressions, "stale suppression")}\n`);
+        diagnose(err, counted(report.totals.stale_suppressions, "stale suppression"));
     }
     if (exitCode === EXIT_CODE_OFF) {
         if (verdict !== EXIT_CLEAN) {
-            err.write(`deadset-ts: the exit code is configured off: the verdict of this run is ${String(verdict)}\n`);
+            diagnose(err, `the exit code is configured off: the verdict of this run is ${String(verdict)}`);
         }
         return EXIT_CLEAN;
     }

package/dist/src/verbs/describe.js

@@ -1,7 +1,7 @@
 import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
 import { CONFORMANCE } from "../conformance.js";
-import { ANALYZER_NAME, LANGUAGE } from "../report.js";
 import {} from "./verb.js";
+import { diagnose, LANGUAGE, message, PRODUCT } from "../product.js";
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
  * report schema versions it reads, the languages it claims, and its recorded result over
@@ -9,7 +9,7 @@ import {} from "./verb.js";
  */
 export function describeDocument(version, recorded) {
     const document = {
-        name: ANALYZER_NAME,
+        name: PRODUCT,
         version,
         contract_version: CONTRACT_VERSION,
         schema_versions_accepted: SCHEMA_VERSIONS,
@@ -29,7 +29,7 @@ export function describeDocument(version, recorded) {
 /** Writes this analyzer's description to the output stream, and nothing to the error stream. */
 export const describeVerb = ({ out, err, host, args }) => {
     if (args.length > 0) {
-        err.write(`deadset-ts: describe takes no argument, got ${JSON.stringify(args[0])}\n`);
+        diagnose(err, `describe takes no argument, got ${JSON.stringify(args[0])}`);
         return EXIT_USAGE;
     }
     let version;
@@ -37,7 +37,7 @@ export const describeVerb = ({ out, err, host, args }) => {
         version = host.analyzerVersion();
     }
     catch (error) {
-        err.write(`deadset-ts: describe: ${error instanceof Error ? error.message : String(error)}\n`);
+        diagnose(err, `describe: ${message(error)}`);
         return EXIT_FAILURE;
     }
     out.write(describeDocument(version, CONFORMANCE));

package/dist/src/verbs/explain.js

@@ -9,6 +9,8 @@ import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
+import { bytewise } from "../text/compare.js";
+import { diagnose } from "../product.js";
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are
  * one request, because exactly one state holds for a symbol and the answer is that state.
@@ -74,7 +76,7 @@ function subjectOf(symbols, named) {
     const partial = symbols
         .filter((symbol) => symbol.ref.toLowerCase().includes(folded) || symbol.name.toLowerCase().includes(folded))
         .map(described)
-        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        .sort(bytewise);
     return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
 /** Every reference of the run once, a reference several configurations make counted once. */
@@ -318,7 +320,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     });
     if (subject === undefined) {
-        err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
+        diagnose(err, `${JSON.stringify(named)} names no one symbol of the target`);
         for (const candidate of candidates) {
             err.write(`  ${candidate}\n`);
         }
@@ -330,7 +332,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         out.write(explanation(analysis, subject, config.reporters.cascade));
     }
     for (const note of notes) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/dist/src/verbs/print-projects.js

@@ -4,6 +4,7 @@ import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { resolveUnkinded } from "../resolve.js";
 import {} from "./verb.js";
+import { diagnose } from "../product.js";
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the
  * build matrix declares for it, or, where discovery derived the project, its
@@ -23,7 +24,7 @@ export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient })
         unanswered: answer.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-retained.js

@@ -5,6 +5,7 @@ import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
+import { diagnose } from "../product.js";
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
  * built from, one per line, and nothing where no exemption held one back. One fact
@@ -27,7 +28,7 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
         unanswered: swept.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-roots.js

@@ -4,6 +4,7 @@ import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
+import { diagnose } from "../product.js";
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string
  * that named it, separated by tabs. A run of several configurations adds the ones
@@ -40,7 +41,7 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
         unanswered: answer.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/dist/src/verbs/version.js

@@ -1,7 +1,8 @@
 import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.js";
 import {} from "./verb.js";
+import { PRODUCT } from "../product.js";
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb = ({ out, host }) => {
-    out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+    out.write(`${PRODUCT} ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
     return EXIT_CLEAN;
 };