@skyramp/mcp 0.3.2-rc.pom-4 → 0.3.3

package/build/tools/code-refactor/reuse-outcome.d.ts

@@ -0,0 +1,109 @@
+import type { VerifyResult } from "../../utils/pom-verify/index.js";
+import { ReuseVerificationOutcome, type ReuseSkippedEntry } from "../../types/ReuseOutcome.js";
+export { ReuseDeclinedBy, ReuseVerificationOutcome, type ReuseOutcome, type ReuseSkippedEntry, } from "../../types/ReuseOutcome.js";
+/** A member the verifier flagged at some point in this run. NOT the same as "a
+ *  member that was demoted": the workflow allows one remap attempt, so a flagged
+ *  member may have been fixed rather than restored to raw inline. Only a
+ *  `// kept inline:` marker proves a decline; this list can at most say which
+ *  member a decline was about. */
+export interface FlaggedMember {
+    pageObject: string;
+    member: string;
+}
+/**
+ * What run state holds between the verify pass and the report step.
+ *
+ * Deliberately NOT an extension of {@link ReuseOutcome}: it is a disjoint type
+ * holding only what cannot be recomputed from the delivered spec. Two reasons.
+ *
+ * Anything recomputable must not be stored, because storing it makes it stale the
+ * moment the spec changes — and it does change: the execution fix-up may restore
+ * `<testFile>.raw.bak` over the spec by plain `cp`, invisible to this tool. The
+ * counts and the decline list are therefore derived at report time (see
+ * `rederiveReuseOutcome`), never read back from here.
+ *
+ * And keeping the two types disjoint makes the report boundary opt-IN. When the
+ * record extended the wire type, every field added here shipped to the
+ * customer-facing report unless someone remembered to widen a destructure — a
+ * default that quietly asserts something, which is the same shape as the
+ * file-level attribution bug this module already had once. Now adding a field is
+ * a type error at the construction site instead.
+ */
+export interface ReuseRecord {
+    /** Tier-1 POM candidate FILES detection found. Not recoverable from the spec:
+     *  it describes what was available to reuse, not what was reused. */
+    candidatesDetected?: number;
+    /** Needs `gateFired`, which only the verify call knows. */
+    verification?: ReuseVerificationOutcome;
+    /** Members the verifier flagged, accumulated across this run's verify passes —
+     *  by the time verification PASSES the violations are gone, so a member that was
+     *  substituted and then restored survives only as a `// kept inline:` comment,
+     *  indistinguishable from one the mapper never promoted.
+     *
+     *  Named for what it holds, not for what it is used to infer: FLAGGED is weaker
+     *  than "demoted" (see {@link FlaggedMember}). Calling it `demoted` is what
+     *  licensed attributing a whole file's declines to one member — do not rename it
+     *  back. */
+    flagged?: FlaggedMember[];
+    /** Identity of the spec to re-derive from, and the language to parse it as. */
+    testFilePath?: string;
+    language?: string;
+}
+/**
+ * Every well-formed `// kept inline: <basename> — <reason>` marker in a spec.
+ *
+ * Deliberately separate from `isKeptInlineDocumented` (verify-gates.ts) rather
+ * than replacing it: that one asks "is THIS known basename documented", so it can
+ * anchor on the basename and never has to guess where the name ends. Loosening the
+ * gate's predicate to share this regex would change when the zero-reuse escape
+ * hatch fires, which is not a side effect worth taking for deduplication — but see
+ * `findUnparsableKeptInline` for how the gap between them is kept visible.
+ */
+export declare function parseKeptInline(specContent: string): {
+    pageObject: string;
+    reason: string;
+}[];
+/**
+ * Lines that announce a kept-inline decline but that `parseKeptInline` cannot
+ * read — a missing reason clause, or a bare unspaced hyphen the zero-reuse gate's
+ * looser predicate would still accept.
+ *
+ * Such a marker satisfies the escape hatch (no gate failure, the agent proceeds)
+ * while the decline never reaches the report: silent signal loss, which is exactly
+ * the failure class this feature exists to close. Callers log these rather than
+ * dropping them quietly.
+ */
+export declare function findUnparsableKeptInline(specContent: string): string[];
+/** Members the verifier flagged in one pass, keyed to the file a decline comment
+ *  would name. */
+export declare function flaggedFrom(r: VerifyResult): FlaggedMember[];
+/** Union two flagged-member lists, deduplicated. */
+export declare function mergeFlagged(prior: FlaggedMember[] | undefined, next: FlaggedMember[]): FlaggedMember[];
+/**
+ * Build the `skipped` list for a spec: one entry per documented kept-inline
+ * marker — markers are the only ground truth for "this was actually left inline".
+ *
+ * Attribution is deliberately conservative, and only labels a decline when the
+ * correspondence is exact — one marker for that file and one flagged member for
+ * it:
+ *
+ *  - No member of the file was ever flagged → the mapper never promoted it,
+ *    `not-mapped`. Unambiguous: a flagged member implies it had been substituted.
+ *  - Exactly one marker and one flagged member → that marker is that member,
+ *    `demoted-by-verify`.
+ *  - Anything else → the entry keeps its reason but carries no `member` and no
+ *    `declinedBy`. Several markers on one file (S-01b's shape: a demote and an
+ *    abstention on the same class) give no way to say which marker is which
+ *    member, and a flagged member may have been remapped successfully rather than
+ *    demoted, so a count mismatch is not even reliably a mixed-cause file.
+ *
+ * Guessing here is worse than omitting: a wrong member under a confident
+ * "demoted by verification" label sends a reviewer chasing a decline that never
+ * happened, which is the multi-hour log dig this field exists to end.
+ */
+export declare function buildSkipped(specContent: string, flagged: FlaggedMember[] | undefined): ReuseSkippedEntry[];
+/** The verdict for a verify pass. A fired compliance gate is a failure regardless
+ *  of the raw result; otherwise `r.ok` decides. `skipped-no-pom` is not reachable
+ *  here — it is recorded on the prompt-generation call, where "no reusable POM
+ *  layer detected" is determined. */
+export declare function verificationFrom(gateFired: boolean, r: VerifyResult): ReuseVerificationOutcome;

package/build/tools/code-refactor/reuse-outcome.js

@@ -0,0 +1,158 @@
+import * as path from "path";
+import { stripStrings } from "../../utils/pom-scope/strip.js";
+import { ReuseDeclinedBy, ReuseVerificationOutcome, } from "../../types/ReuseOutcome.js";
+/**
+ * Server-side derivation of a UI test's POM code-reuse outcome.
+ *
+ * The counts and verdicts here are all computed in-process by `skyramp_reuse_code`
+ * already — tier-1 detection by `selectScopedPoms`, the call counts and violations
+ * by `verifyReuse`, the demote/abstain record by the `// kept inline:` comments in
+ * the spec the tool just read. Routing them through the agent (read four integers
+ * out of tool text, hold them across the rest of the run, retype them into a later
+ * call) is still prose-mediated and still droppable, which is the failure this
+ * whole feature exists to fix. So they are persisted to run state and merged into
+ * the report server-side, exactly as `beforeStatus`/`afterStatus` are.
+ *
+ * The agent supplies nothing here.
+ */
+/** Separator between composite-key parts. `\0` cannot occur in a file name or a
+ *  reason clause, so it cannot collide — written as an escape, never as a literal
+ *  control byte, or git classifies this source file as binary. */
+const KEY_SEP = "\0";
+// The wire shape lives in types/ (and is re-exported from types/index.ts for
+// consumers). Re-exported here so this module stays the one place to look when
+// working on the derivation.
+export { ReuseDeclinedBy, ReuseVerificationOutcome, } from "../../types/ReuseOutcome.js";
+/** Matches a well-formed `// kept inline: <basename> <sep> <reason>` marker.
+ *
+ *  The separator must be an em/en dash or a *spaced* hyphen. Discovery has no
+ *  anchor to tell where the file name ends, and a bare hyphen is ambiguous with
+ *  hyphens inside file names (`alert-destinations.page.ts-reason`), so requiring
+ *  whitespace is what makes the split decidable. `findUnparsableKeptInline` below
+ *  reports anything that looks like a marker but does not match, so a malformed
+ *  one is never silently lost. */
+const KEPT_INLINE_RE = /\/\/\s*kept inline:\s*(\S.*?)\s*(?:[—–]+|\s+-+\s+)\s*(\S.*?)\s*$/;
+/** Lines that look like a kept-inline marker. Deliberately looser than
+ *  KEPT_INLINE_RE so the difference between the two is detectable. */
+const KEPT_INLINE_LOOSE_RE = /\/\/\s*kept inline:/;
+/** Comment lines only — a marker quoted inside a string literal is not a real
+ *  marker, the same reasoning as the zero-reuse gate's predicate. */
+function commentLines(specContent) {
+    return stripStrings(specContent).split("\n");
+}
+/**
+ * Every well-formed `// kept inline: <basename> — <reason>` marker in a spec.
+ *
+ * Deliberately separate from `isKeptInlineDocumented` (verify-gates.ts) rather
+ * than replacing it: that one asks "is THIS known basename documented", so it can
+ * anchor on the basename and never has to guess where the name ends. Loosening the
+ * gate's predicate to share this regex would change when the zero-reuse escape
+ * hatch fires, which is not a side effect worth taking for deduplication — but see
+ * `findUnparsableKeptInline` for how the gap between them is kept visible.
+ */
+export function parseKeptInline(specContent) {
+    const out = [];
+    const seen = new Set();
+    for (const line of commentLines(specContent)) {
+        const m = KEPT_INLINE_RE.exec(line);
+        if (!m)
+            continue;
+        const pageObject = path.basename(m[1].trim());
+        const reason = m[2].trim();
+        const key = `${pageObject}${KEY_SEP}${reason}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ pageObject, reason });
+    }
+    return out;
+}
+/**
+ * Lines that announce a kept-inline decline but that `parseKeptInline` cannot
+ * read — a missing reason clause, or a bare unspaced hyphen the zero-reuse gate's
+ * looser predicate would still accept.
+ *
+ * Such a marker satisfies the escape hatch (no gate failure, the agent proceeds)
+ * while the decline never reaches the report: silent signal loss, which is exactly
+ * the failure class this feature exists to close. Callers log these rather than
+ * dropping them quietly.
+ */
+export function findUnparsableKeptInline(specContent) {
+    return commentLines(specContent)
+        .filter((line) => KEPT_INLINE_LOOSE_RE.test(line) && !KEPT_INLINE_RE.test(line))
+        .map((line) => line.trim());
+}
+/** Members the verifier flagged in one pass, keyed to the file a decline comment
+ *  would name. */
+export function flaggedFrom(r) {
+    const out = [];
+    for (const v of r.violations) {
+        const file = v.searched[0];
+        if (file)
+            out.push({ pageObject: path.basename(file), member: `${v.binding}.${v.member}` });
+    }
+    return out;
+}
+/** Union two flagged-member lists, deduplicated. */
+export function mergeFlagged(prior, next) {
+    const byKey = new Map();
+    for (const d of [...(prior ?? []), ...next]) {
+        byKey.set(`${d.pageObject}${KEY_SEP}${d.member}`, d);
+    }
+    return [...byKey.values()];
+}
+function countByFile(items) {
+    const counts = new Map();
+    for (const i of items)
+        counts.set(i.pageObject, (counts.get(i.pageObject) ?? 0) + 1);
+    return counts;
+}
+/**
+ * Build the `skipped` list for a spec: one entry per documented kept-inline
+ * marker — markers are the only ground truth for "this was actually left inline".
+ *
+ * Attribution is deliberately conservative, and only labels a decline when the
+ * correspondence is exact — one marker for that file and one flagged member for
+ * it:
+ *
+ *  - No member of the file was ever flagged → the mapper never promoted it,
+ *    `not-mapped`. Unambiguous: a flagged member implies it had been substituted.
+ *  - Exactly one marker and one flagged member → that marker is that member,
+ *    `demoted-by-verify`.
+ *  - Anything else → the entry keeps its reason but carries no `member` and no
+ *    `declinedBy`. Several markers on one file (S-01b's shape: a demote and an
+ *    abstention on the same class) give no way to say which marker is which
+ *    member, and a flagged member may have been remapped successfully rather than
+ *    demoted, so a count mismatch is not even reliably a mixed-cause file.
+ *
+ * Guessing here is worse than omitting: a wrong member under a confident
+ * "demoted by verification" label sends a reviewer chasing a decline that never
+ * happened, which is the multi-hour log dig this field exists to end.
+ */
+export function buildSkipped(specContent, flagged) {
+    const markers = parseKeptInline(specContent);
+    const markerCounts = countByFile(markers);
+    const flaggedByFile = new Map();
+    for (const f of flagged ?? []) {
+        const members = flaggedByFile.get(f.pageObject) ?? [];
+        members.push(f.member);
+        flaggedByFile.set(f.pageObject, members);
+    }
+    return markers.map(({ pageObject, reason }) => {
+        const members = flaggedByFile.get(pageObject) ?? [];
+        if (members.length === 0) {
+            return { pageObject, declinedBy: ReuseDeclinedBy.NotMapped, reason };
+        }
+        if (members.length === 1 && markerCounts.get(pageObject) === 1) {
+            return { pageObject, member: members[0], declinedBy: ReuseDeclinedBy.DemotedByVerify, reason };
+        }
+        return { pageObject, reason };
+    });
+}
+/** The verdict for a verify pass. A fired compliance gate is a failure regardless
+ *  of the raw result; otherwise `r.ok` decides. `skipped-no-pom` is not reachable
+ *  here — it is recorded on the prompt-generation call, where "no reusable POM
+ *  layer detected" is determined. */
+export function verificationFrom(gateFired, r) {
+    return !gateFired && r.ok ? ReuseVerificationOutcome.Passed : ReuseVerificationOutcome.Failed;
+}

package/build/tools/code-refactor/reuse-state.d.ts

@@ -0,0 +1,45 @@
+import { type VerifyResult } from "../../utils/pom-verify/index.js";
+import { type ReuseOutcome, type ReuseRecord } from "./reuse-outcome.js";
+/** Record the tier-1 candidate count STEP 1 detected. */
+export declare function recordCandidates(testFile: string, candidatesDetected: number, explicitStateFile?: string): Promise<void>;
+/** The prompt-generation call found no reusable POM layer at all. No candidate
+ *  count is recorded: "0 candidates" adds nothing to "no POM layer was found",
+ *  and rendering both produces a redundant zero in the summary. */
+export declare function recordNoPomLayer(testFile: string, explicitStateFile?: string): Promise<void>;
+/**
+ * Record what one verify pass established: the call counts, the verdict, and the
+ * declines read out of the spec the verifier just parsed.
+ *
+ * `flagged` accumulates across passes because a PASSED verdict has no violations
+ * left to inspect — a member that was substituted and then restored survives only
+ * as a `// kept inline:` comment, indistinguishable from one the mapper never
+ * promoted. Accumulating is what keeps that distinction recoverable at all; it does
+ * not by itself establish it, since a flagged member may have been remapped rather
+ * than restored (see buildSkipped for how narrowly it is trusted).
+ */
+export declare function recordVerifyOutcome(testFile: string, r: VerifyResult, gateFired: boolean, language: string, explicitStateFile?: string): Promise<void>;
+/**
+ * Re-derive a recorded outcome from the spec as it stands NOW, so the report
+ * describes the delivered artifact rather than the state at verify time.
+ *
+ * The two can differ: the execution fix-up may restore `<testFile>.raw.bak` over
+ * the spec after verification, reverting every substitution with a plain `cp` that
+ * this tool never sees. Trusting the recorded counts there would publish
+ * `callsReused: 5, verification: "passed"` for a spec containing no POM calls —
+ * a confident false claim, strictly worse than the silence this feature replaced.
+ * Re-deriving here rather than requiring a final `verify: true` pass is deliberate:
+ * the report step always runs, so the agent cannot skip it.
+ *
+ * `candidatesDetected` is kept as recorded — it counts POM FILES that detection
+ * found, which a restore does not change. Everything else comes from the file.
+ *
+ * `verification` is dropped when the delivered spec reuses nothing: a PASSED
+ * verdict describes a spec that no longer exists, and pairing it with a zero count
+ * reads as though the empty result had been blessed.
+ *
+ * Returns the recorded outcome minus internals when re-derivation is impossible
+ * (no path recorded — e.g. only the candidate count was ever written), and
+ * `undefined` when it fails outright. Failing closed matters: falling back to the
+ * recorded counts is exactly the false claim this exists to prevent.
+ */
+export declare function rederiveReuseOutcome(record: ReuseRecord): Promise<ReuseOutcome | undefined>;

package/build/tools/code-refactor/reuse-state.js

@@ -0,0 +1,140 @@
+import * as path from "path";
+import { readFile } from "fs/promises";
+import { logger } from "../../utils/logger.js";
+import { resolveRunStatePath, StateManager, } from "../../utils/AnalysisStateManager.js";
+import { verifyReuse } from "../../utils/pom-verify/index.js";
+import { buildSkipped, findUnparsableKeptInline, flaggedFrom, mergeFlagged, verificationFrom, ReuseVerificationOutcome, } from "./reuse-outcome.js";
+/**
+ * Persistence for the server-derived POM-reuse outcome, keyed by test-file
+ * basename (what `newTestsCreated[].fileName` carries, so
+ * `skyramp_submit_report` can match without path normalization).
+ *
+ * Every write is best-effort. Reuse observability must never be able to fail a
+ * refactor that otherwise succeeded, so a missing/unreadable/unwritable state
+ * file degrades to "no reuse summary in the report" — the same outcome as running
+ * outside a Testbot run, where there is no run state to record into.
+ */
+/**
+ * Read-modify-write one spec's outcome. `patch` receives the entry recorded so
+ * far, so a caller that needs prior state (the verify pass, which accumulates
+ * flagged members) uses the same path as one that does not.
+ *
+ * Fields the patch omits are preserved: the prompt-generation call knows the
+ * candidate count, each verify pass knows the counts and verdict.
+ */
+async function updateReuseOutcome(testFile, patch, explicitStateFile) {
+    const stateFile = resolveRunStatePath(explicitStateFile);
+    if (!stateFile)
+        return;
+    try {
+        const manager = StateManager.fromStatePath(stateFile);
+        const data = await manager.readData();
+        if (!data)
+            return;
+        const key = path.basename(testFile);
+        const existing = data.reuseOutcomes?.[key] ?? {};
+        await manager.writeData({
+            ...data,
+            reuseOutcomes: { ...data.reuseOutcomes, [key]: { ...existing, ...patch(existing) } },
+        });
+    }
+    catch (err) {
+        logger.warning("Could not record POM-reuse outcome — report will omit the reuse summary", {
+            testFile,
+            error: String(err),
+        });
+    }
+}
+/** Record the tier-1 candidate count STEP 1 detected. */
+export async function recordCandidates(testFile, candidatesDetected, explicitStateFile) {
+    await updateReuseOutcome(testFile, () => ({ candidatesDetected }), explicitStateFile);
+}
+/** The prompt-generation call found no reusable POM layer at all. No candidate
+ *  count is recorded: "0 candidates" adds nothing to "no POM layer was found",
+ *  and rendering both produces a redundant zero in the summary. */
+export async function recordNoPomLayer(testFile, explicitStateFile) {
+    await updateReuseOutcome(testFile, () => ({ verification: ReuseVerificationOutcome.SkippedNoPom }), explicitStateFile);
+}
+/**
+ * Record what one verify pass established: the call counts, the verdict, and the
+ * declines read out of the spec the verifier just parsed.
+ *
+ * `flagged` accumulates across passes because a PASSED verdict has no violations
+ * left to inspect — a member that was substituted and then restored survives only
+ * as a `// kept inline:` comment, indistinguishable from one the mapper never
+ * promoted. Accumulating is what keeps that distinction recoverable at all; it does
+ * not by itself establish it, since a flagged member may have been remapped rather
+ * than restored (see buildSkipped for how narrowly it is trusted).
+ */
+export async function recordVerifyOutcome(testFile, r, gateFired, language, explicitStateFile) {
+    if (!resolveRunStatePath(explicitStateFile))
+        return;
+    await updateReuseOutcome(testFile, (existing) => {
+        const flagged = mergeFlagged(existing.flagged, flaggedFrom(r));
+        return {
+            testFilePath: testFile,
+            language,
+            verification: verificationFrom(gateFired, r),
+            ...(flagged.length > 0 ? { flagged } : {}),
+        };
+    }, explicitStateFile);
+}
+/**
+ * Re-derive a recorded outcome from the spec as it stands NOW, so the report
+ * describes the delivered artifact rather than the state at verify time.
+ *
+ * The two can differ: the execution fix-up may restore `<testFile>.raw.bak` over
+ * the spec after verification, reverting every substitution with a plain `cp` that
+ * this tool never sees. Trusting the recorded counts there would publish
+ * `callsReused: 5, verification: "passed"` for a spec containing no POM calls —
+ * a confident false claim, strictly worse than the silence this feature replaced.
+ * Re-deriving here rather than requiring a final `verify: true` pass is deliberate:
+ * the report step always runs, so the agent cannot skip it.
+ *
+ * `candidatesDetected` is kept as recorded — it counts POM FILES that detection
+ * found, which a restore does not change. Everything else comes from the file.
+ *
+ * `verification` is dropped when the delivered spec reuses nothing: a PASSED
+ * verdict describes a spec that no longer exists, and pairing it with a zero count
+ * reads as though the empty result had been blessed.
+ *
+ * Returns the recorded outcome minus internals when re-derivation is impossible
+ * (no path recorded — e.g. only the candidate count was ever written), and
+ * `undefined` when it fails outright. Failing closed matters: falling back to the
+ * recorded counts is exactly the false claim this exists to prevent.
+ */
+export async function rederiveReuseOutcome(record) {
+    const { candidatesDetected, verification, flagged, testFilePath, language } = record;
+    // No verify pass ran for this spec, so there are no counts to derive — only the
+    // detection-time facts, which no spec change can invalidate.
+    if (!testFilePath || !language)
+        return { candidatesDetected, verification };
+    try {
+        const r = await verifyReuse(testFilePath, language);
+        const specContent = await readFile(testFilePath, "utf8");
+        // Diagnose the file the report is actually built from. A marker the zero-reuse
+        // gate accepts but this cannot parse satisfies the escape hatch while its
+        // decline never reaches the report — silent signal loss is the failure class
+        // this feature exists to close.
+        const unparsable = findUnparsableKeptInline(specContent);
+        if (unparsable.length > 0) {
+            logger.warning("Malformed `// kept inline:` marker(s) in the delivered spec — these declines will be missing from the PR report. " +
+                "Use `// kept inline: <file basename> — <reason>` (em dash, or a hyphen with spaces around it).", { testFile: testFilePath, markers: unparsable });
+        }
+        const skipped = buildSkipped(specContent, flagged);
+        return {
+            candidatesDetected,
+            callsReused: r.reusedCalls,
+            callsVerified: r.checkedCalls,
+            // A PASSED verdict describes a spec that no longer exists once reuse is gone,
+            // and pairing it with a zero count reads as though the empty result had been
+            // blessed.
+            verification: r.reusedCalls > 0 ? verification : undefined,
+            skipped: skipped.length > 0 ? skipped : undefined,
+        };
+    }
+    catch (err) {
+        logger.warning("Could not re-derive the POM-reuse outcome from the delivered spec — omitting the reuse summary rather than reporting counts that may no longer hold", { testFile: testFilePath, error: String(err) });
+        return undefined;
+    }
+}

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export declare function registerEnrichTestWithMocksTool(server: McpServer): void;
+declare function injectMockImports(original: string, testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+declare function isSupportedMockEnrichmentLanguage(language: ProgrammingLanguage | string): language is ProgrammingLanguage;
+type MockEntry = {
+    serviceName: string;
+    moduleName: string;
+    relativePath: string;
+    importPath: string;
+    importLabel: string;
+    mockFile: string;
+    className: string;
+    classReference: string;
+    targetUrl?: string;
+    protocol: MockProtocol;
+};
+declare function buildMockImportBlock(testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage, mockEntries?: MockEntry[]): string;
+export { injectMockImports, buildMockImportBlock, isSupportedMockEnrichmentLanguage };