micro-models-agent 0.41.2 → 0.43.0

package/dist/modules/context/manager.js

@@ -1,5 +1,4 @@
 import { getMessageText } from "../../llm/provider";
-import { FactExtractor } from "./fact-extractor";
 const COMPACTION_INTERVAL = 15;
 const KEEP_LAST_N = 6;
 function summarizeArgs(args) {
@@ -20,28 +19,15 @@ function truncate(s, max) {
         return s;
     return s.slice(0, max - 3) + "...";
 }
-function looksLikeErrorPaste(text) {
-    // Error markers.
-    if (/(?:^|\s)ERROR|Error:|error TS\d+|Transform failed|\[plugin:|SyntaxError|Cannot find|Uncaught|exception/i.test(text)) {
-        return true;
-    }
-    // Structural signals of pasted compiler/runtime output: source frames
-    // ("270|  }_s(...)"), path:line:col references, and stack-trace lines.
-    if (/(?:^|\n)\s*\d+\s*\|/.test(text))
-        return true;
-    if (/[\w./\\-]+\.[a-z]{1,6}:\d+:\d+/.test(text))
-        return true;
-    if (/(?:^|\n)\s*at\s+\S+/.test(text))
-        return true;
-    return false;
-}
 export function extractTriedAndFailed(messages) {
     const failures = new Map();
     for (const msg of messages) {
         if (msg.role === "tool" && msg.name && msg.success === false) {
             const key = `${msg.name}:${summarizeArgs(msg.arguments)}`;
             const existing = failures.get(key);
-            const errorText = truncate(typeof msg.content === "string" ? msg.content : getMessageText(msg.content), 100);
+            const errorText = truncate(typeof msg.content === "string"
+                ? msg.content
+                : getMessageText(msg.content), 100);
             if (existing) {
                 existing.count++;
             }
@@ -66,38 +52,20 @@ export class ContextManager {
     peakTokens = 0;
     budget;
     compactionThreshold;
-    facts = new FactExtractor();
-    /** Latest real user instruction (skips <system-summary> blocks). */
-    lastUserTask = "";
-    /** First real user instruction of the session — survives resetUserTurn(). */
-    sessionMission = "";
-    /** Latest user message that looks like a pasted error/log (never a task). */
-    lastUserFeedback = "";
+    fileFacts = [];
+    decisionFacts = [];
+    errorFacts = [];
+    static MAX_FACTS = 20;
     tokenCounter;
     pendingImageParts = [];
     toolTokens = 0;
     onCompact = null;
-    /**
-     * Optional short line appended to the compaction summary so the model knows
-     * an active plan exists with progress. Wired from bootstrap to the execution
-     * module — without it, a 9B model re-creates a plan from scratch right after
-     * compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) was discarded for a
-     * fresh plan_xzq9xe the same iteration the old plan was still visible).
-     */
-    planSummaryProvider = null;
     constructor(contextWindow, contextBudget, tokenCounter) {
         this.contextWindow = contextWindow;
         this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
         this.budget = this.calculateBudget(contextWindow, contextBudget);
         this.tokenCounter = tokenCounter ?? null;
     }
-    /**
-     * Provide a short "current plan" line for the compaction summary, or null
-     * when no plan is active. Injected once at bootstrap (not per-turn state).
-     */
-    setPlanSummaryProvider(fn) {
-        this.planSummaryProvider = fn;
-    }
     calculateBudget(window, contextBudget) {
         if (contextBudget) {
             const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
@@ -124,67 +92,27 @@ export class ContextManager {
     noteIteration() {
         this.iterationsSinceCompaction++;
     }
-    /**
-     * Start a fresh user turn. The 15-iteration compaction interval must not
-     * leak across user messages — otherwise a turn that ends at iteration 14
-     * forces a compaction on the very first iteration of the next user message
-     * (observed: compaction fired on iteration 8 of a new turn, deleting the
-     * user's freshly-sent task alongside 40+ old turns). Facts are kept.
-     */
-    resetUserTurn() {
-        this.iterationsSinceCompaction = 0;
-        // A new user message begins a new turn — drop the previous turn's task
-        // so the fresh instruction becomes the one preserved at compaction. The
-        // session mission survives: an error/log paste in the new turn must not
-        // erase the original goal.
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-    }
     getQuality() {
         const usedTokens = this.getEstimatedTokens();
         const tokenLoad = Math.max(0, 1 - usedTokens / this.budget.history);
-        // Recoverable penalty: each compaction loses some information, but the
-        // penalty is CAPPED so cumulative compactions can never permanently pin
-        // quality below the forced-compaction trigger (40%). Before this cap, a
-        // session with ~7+ compactions clamped the term to 0 forever; combined
-        // with heavy token load + error density, quality stuck below 40 and a
-        // compaction fired on EVERY iteration (observed: 56 compactions in 28 min).
-        const COMPACTION_PENALTY_FLOOR = 0.5;
-        const compactionLoss = Math.max(COMPACTION_PENALTY_FLOOR, 1 - this.compactionCount * 0.15);
+        const compactionLoss = Math.max(0, 1 - this.compactionCount * 0.15);
         const msgCount = this.messages.length || 1;
-        const errorDensity = Math.max(0, 1 - Math.min(1, this.facts.errorCount / msgCount));
+        const errorDensity = Math.max(0, 1 - Math.min(1, this.errorFacts.length / msgCount));
         const freshness = Math.max(0, 1 - this.iterationsSinceCompaction / COMPACTION_INTERVAL);
-        const score = tokenLoad * 0.4 + compactionLoss * 0.25 + errorDensity * 0.2 + freshness * 0.15;
+        const score = tokenLoad * 0.4 +
+            compactionLoss * 0.25 +
+            errorDensity * 0.2 +
+            freshness * 0.15;
         return Math.round(Math.min(100, Math.max(0, score * 100)));
     }
     addMessage(msg) {
-        // Track the task the agent is working on so it survives compaction. The
-        // user's real instruction is the FIRST non-system-summary user message of
-        // the turn; everything after it (tool results, retry nudges) are injected
-        // `user` envelopes that must not overwrite it (observed: after compaction
-        // the model had forgotten "удали /bicycles, почини стили" and re-read
-        // files aimlessly for 40+ iterations).
-        if (msg.role === "user") {
-            const text = typeof msg.content === "string" ? msg.content : getMessageText(msg.content);
-            if (text.trim() && !text.startsWith("<system-summary>") && !text.includes("[Compressed:")) {
-                if (looksLikeErrorPaste(text) && (this.lastUserTask || this.sessionMission)) {
-                    this.lastUserFeedback = text.trim().slice(0, 400);
-                }
-                else if (!this.lastUserTask && !this.lastUserFeedback) {
-                    // No new task inside a turn that already captured an error/log paste:
-                    // the paste's follow-up messages are tool-result continuations, not a
-                    // fresh instruction, so the session mission must win at compaction.
-                    this.lastUserTask = text.trim();
-                    if (!this.sessionMission)
-                        this.sessionMission = text.trim();
-                }
-            }
-        }
         // Auto-attach pending images to the next user message
         if (msg.role === "user" && this.pendingImageParts.length > 0) {
             const textPart = {
                 type: "text",
-                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
+                text: typeof msg.content === "string"
+                    ? msg.content
+                    : getMessageText(msg.content),
             };
             msg = {
                 ...msg,
@@ -278,53 +206,27 @@ export class ContextManager {
         return totalTokens > this.budget.history * this.compactionThreshold;
     }
     compact() {
-        // Capture the pre-compaction state BEFORE any counters reset or rise —
-        // qualityBefore must reflect the context the model actually saw.
-        const tokensBefore = this.getEstimatedTokens();
-        const qualityBefore = this.getQuality();
-        const messagesBefore = this.messages.length;
         // Reset the counter even when nothing to compact — otherwise
         // needsCompaction() returns true forever after 15 iterations with few messages.
         this.iterationsSinceCompaction = 0;
         if (this.messages.length <= KEEP_LAST_N * 2)
-            return null;
+            return;
         this.compactionCount++;
         const cutoff = this.messages.length - KEEP_LAST_N * 2;
         const oldTurns = this.messages.slice(0, cutoff);
         const recentTurns = this.messages.slice(cutoff);
-        this.facts.extract(oldTurns);
+        this.extractFacts(oldTurns);
         const parts = [];
         parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        // Carry the user's actual instruction forward — the model must never lose
-        // the task it is working on just because 40 turns got compacted away. The
-        // per-turn task falls back to the session mission (first real instruction)
-        // so a pasted error/log in the current turn cannot erase the goal.
-        const task = (this.lastUserTask || this.sessionMission).slice(0, 400);
-        if (task)
-            parts.push(`[Task: ${task}]`);
-        if (this.lastUserFeedback && !task.startsWith(this.lastUserFeedback)) {
-            parts.push(`[User feedback: ${this.lastUserFeedback}]`);
+        if (this.fileFacts.length > 0) {
+            parts.push(`[Files: ${this.fileFacts.slice(-15).join("; ")}]`);
+        }
+        if (this.decisionFacts.length > 0) {
+            parts.push(`[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`);
+        }
+        if (this.errorFacts.length > 0) {
+            parts.push(`[Errors: ${this.errorFacts.slice(-3).join("; ")}]`);
         }
-        // Orient the model after compaction: an active plan must not be re-created
-        // from scratch (see planSummaryProvider doc).
-        const planLine = this.planSummaryProvider?.();
-        if (planLine)
-            parts.push(`[Plan: ${planLine}]`);
-        const filesLine = this.facts.filesLine();
-        if (filesLine)
-            parts.push(filesLine);
-        const deletedLine = this.facts.deletedLine();
-        if (deletedLine)
-            parts.push(deletedLine);
-        const readLine = this.facts.readLine();
-        if (readLine)
-            parts.push(readLine);
-        const decisionsLine = this.facts.decisionsLine();
-        if (decisionsLine)
-            parts.push(decisionsLine);
-        const errorsLine = this.facts.errorsLine();
-        if (errorsLine)
-            parts.push(errorsLine);
         const triedAndFailed = extractTriedAndFailed(oldTurns);
         if (triedAndFailed.length > 0) {
             const lines = triedAndFailed.map((t) => `- ${t.tool}(${t.args}): ${t.error} (failed ${t.count}x)`);
@@ -343,38 +245,69 @@ export class ContextManager {
             const text = getMessageText(m.content);
             return !text.startsWith("<system-summary>");
         });
-        this.messages = [...(firstSystem ? [firstSystem] : []), summary, ...freshRecent];
+        this.messages = [
+            ...(firstSystem ? [firstSystem] : []),
+            summary,
+            ...freshRecent,
+        ];
         this.iterationsSinceCompaction = 0;
         if (this.onCompact) {
             this.onCompact(summary);
         }
-        return {
-            removedTurns: oldTurns.length,
-            keptTurns: freshRecent.length,
-            tokensBefore,
-            tokensAfter: this.getEstimatedTokens(),
-            qualityBefore,
-            qualityAfter: this.getQuality(),
-            messagesBefore,
-            messagesAfter: this.messages.length,
-            summary: this.compactedBlock ?? "",
-        };
     }
-    /**
-     * Snapshot of the current context state — used to log the initial context
-     * structure at session start and per-iteration context stats.
-     */
-    getSnapshot() {
-        return {
-            window: this.contextWindow,
-            budget: { ...this.budget },
-            tokens: this.getEstimatedTokens(),
-            toolTokens: this.toolTokens,
-            messageCount: this.messages.length,
-            quality: this.getQuality(),
-            compactionCount: this.compactionCount,
-            iterationsSinceCompaction: this.iterationsSinceCompaction,
-        };
+    extractFacts(turns) {
+        const filePatterns = [
+            /(?:Created|Updated|Written|Deleted|Moved) ([\w./\\-]+\.[a-z]+)/gi,
+            /Файл (?:создан|обновлён|записан|удалён|перемещён):? ([\w./\\-]+\.[a-z]+)/gi,
+            /file (?:created|updated|written|deleted|moved):? ([\w./\\-]+\.[a-z]+)/gi,
+        ];
+        const newFiles = [];
+        const newDecisions = [];
+        const newErrors = [];
+        for (const msg of turns) {
+            const content = getMessageText(msg.content);
+            if (msg.role === "tool") {
+                for (const pattern of filePatterns) {
+                    for (const match of content.matchAll(pattern)) {
+                        newFiles.push(match[1]);
+                    }
+                }
+                if (content.includes("Plan:") && content.includes("[")) {
+                    const planLine = content
+                        .split("\n")
+                        .find((line) => line.includes("Plan:"));
+                    if (planLine)
+                        newDecisions.push(planLine.trim());
+                }
+            }
+            if (msg.role === "assistant") {
+                if (content.includes("decided:") || content.includes("decision:")) {
+                    const line = content
+                        .split("\n")
+                        .find((l) => l.includes("decided:") || l.includes("decision:"));
+                    if (line)
+                        newDecisions.push(line.trim().slice(0, 200));
+                }
+            }
+            if (content.includes("Error:") ||
+                content.includes("failed") ||
+                content.includes("Ошибка:") ||
+                content.includes("не удалось")) {
+                const line = content
+                    .split("\n")
+                    .find((l) => l.includes("Error:") ||
+                    l.includes("failed") ||
+                    l.includes("Ошибка:") ||
+                    l.includes("не удалось"));
+                if (line)
+                    newErrors.push(line.trim().slice(0, 250));
+            }
+        }
+        // Deduplicate and cap facts to prevent unbounded growth
+        const dedup = (arr) => [...new Set(arr)];
+        this.fileFacts = dedup([...this.fileFacts, ...newFiles]).slice(-ContextManager.MAX_FACTS);
+        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-ContextManager.MAX_FACTS);
+        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-ContextManager.MAX_FACTS);
     }
     /**
      * Replace the system prompt in place (keeps it first) or prepend a new one.
@@ -392,23 +325,16 @@ export class ContextManager {
     getActiveHistory() {
         return [...this.messages];
     }
-    /**
-     * Reset everything that belongs to the current conversation turn.
-     * Fact lists (FactExtractor) intentionally survive clear() — they are
-     * session-scoped compaction state, not per-turn.
-     */
     clear() {
         this.messages = [];
         this.compactedBlock = null;
         this.iterationsSinceCompaction = 0;
         this.compactionCount = 0;
         this.peakTokens = 0;
-        this.lastUserTask = "";
-        this.lastUserFeedback = "";
-        this.sessionMission = "";
     }
     getEstimatedTokens() {
-        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) + this.toolTokens);
+        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) +
+            this.toolTokens);
     }
     setToolTokens(tokens) {
         this.toolTokens = tokens;

package/dist/modules/execution/auditor.js

@@ -1,218 +1,66 @@
-import { existsSync, readdirSync } from "fs";
-import { resolve, join, basename } from "path";
+import { existsSync } from "fs";
+import { resolve } from "path";
 import { t } from "../../i18n/index";
-import { extractFileLikeTokens, stripUrls } from "../hallucination/js-identifiers";
-import { SKIP_DIRS, findTestFile, findTypecheckRoot, hasTestStep, runTests, runTypecheck, } from "./audit-runners";
-export { parseTypecheckErrors } from "./audit-runners";
+import { isJsMemberAccess } from "../hallucination/js-identifiers";
 const MASS_EDIT_THRESHOLD = 10;
-/** Subtree walk depth cap for file resolution. */
-const RESOLVE_MAX_DEPTH = 8;
-/**
- * Resolve a plan-step file token to an existing file.
- *
- * A step description frequently names a file by its bare basename
- * ("App.tsx") or a partially-prefixed path ("src/App.tsx") while the real
- * file lives in a nested project directory relative to the agent baseDir
- * (e.g. `bicycle-shop/src/App.tsx`). Naively resolving against baseDir
- * reports the file as missing — observed in session ses_mssl5izw where the
- * final audit gate rejected a fully-completed task with "1 files missing"
- * forever, sending the model into a read/retry loop.
- *
- * Strategy: exact resolve first, then a bounded subtree walk matching either
- * the exact basename or a path suffix (so both "App.tsx" and
- * "src/App.tsx" find "bicycle-shop/src/App.tsx").
- */
-export function findExistingFile(baseDir, filePath) {
-    const direct = resolve(baseDir, filePath);
-    if (existsSync(direct))
-        return direct;
-    const name = basename(filePath).toLowerCase();
-    const suffix = filePath.replace(/\\/g, "/").toLowerCase();
-    let found = null;
-    const walk = (dir, depth) => {
-        if (found || depth > RESOLVE_MAX_DEPTH)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const e of entries) {
-            if (found)
-                return;
-            const full = join(dir, e.name);
-            if (e.isDirectory()) {
-                if (SKIP_DIRS.has(e.name))
-                    continue;
-                walk(full, depth + 1);
-            }
-            else if (e.name.toLowerCase() === name ||
-                full
-                    .replace(/\\/g, "/")
-                    .toLowerCase()
-                    .endsWith("/" + suffix)) {
-                found = full;
-                return;
-            }
-        }
-    };
-    walk(baseDir, 0);
-    return found;
-}
 export class Auditor {
     baseDir;
     constructor(baseDir) {
         this.baseDir = baseDir;
     }
     async audit(plan) {
-        // Only steps the model claims completed may require their named files to
-        // exist. Skipped/pending steps must never contribute "missing files"
-        // (observed: a skipped step's prose mention of "type.ts" kept the audit
-        // gate rejecting a finished task with "1 files missing" forever).
-        const doneCreate = plan.steps.filter((s) => s.status === "done" && s.kind !== "delete");
-        const doneDelete = plan.steps.filter((s) => s.status === "done" && s.kind === "delete");
-        const createText = doneCreate.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-        const deleteText = doneDelete.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-        // File tokens are extracted with the SAME shared filter as the
-        // hallucination factual check (js-identifiers.ts). URLs are stripped
-        // first so a hostname / https://host/repo.git in a step description
-        // can never be reported as a missing file (observed: a git-remote
-        // plan flagged `whom-pointing-jewel-maine.trycloudflare.com`).
-        const createFiles = extractFileLikeTokens(stripUrls(createText));
-        const deleteFiles = extractFileLikeTokens(stripUrls(deleteText));
+        const allStepText = plan.steps
+            .map((s) => s.description.replace(/\([^)]*\)/g, " "))
+            .join(" ");
+        const fileMatches = allStepText.match(/\b[\w./-]+\.[a-z]+/gi) || [];
+        // process.env / console.log in step descriptions are JS member access,
+        // not files — drop them before existence checks (false "missing file"
+        // warnings).
+        const uniqueFiles = [
+            ...new Set(fileMatches.filter((f) => !isJsMemberAccess(f))),
+        ];
         const missingFiles = [];
         const existingFiles = [];
-        const leftoverFiles = [];
-        for (const filePath of createFiles) {
-            const resolved = findExistingFile(this.baseDir, filePath);
-            if (resolved) {
-                // Keep the resolved absolute path: findTypecheckRoot walks up
-                // from it to the nearest tsconfig, and a relative token would
-                // resolve against the process cwd instead of baseDir.
-                existingFiles.push(resolved);
+        for (const filePath of uniqueFiles) {
+            const resolved = resolve(this.baseDir, filePath);
+            if (existsSync(resolved)) {
+                existingFiles.push(filePath);
             }
             else {
                 missingFiles.push(filePath);
             }
         }
-        // A done delete-kind step requires its named files to be GONE.
-        for (const filePath of deleteFiles) {
-            if (findExistingFile(this.baseDir, filePath)) {
-                leftoverFiles.push(filePath);
-            }
-        }
-        // Real test run: when the plan includes a verification step, do not
-        // trust the model's word (or exit codes) — actually execute the tests
-        // and check the runner summary. This catches the "all 7 passing ✅"
-        // final answers that hide 3 failing tests.
-        let testRun = null;
-        if (hasTestStep(plan) && findTestFile(this.baseDir)) {
-            try {
-                testRun = await runTests(this.baseDir);
-            }
-            catch {
-                testRun = null; // infra failure — don't block on it
-            }
-        }
-        // Real typecheck: the audit must catch "the build is broken" even when
-        // every file exists (observed: deleting .js files left the .tsx sources
-        // with 11 tsc errors and the agent still declared success). Runs only
-        // when a tsconfig.json is reachable from baseDir or the resolved step
-        // files AND the file checks already passed — an audit that is doomed by
-        // missing/leftover files must not pay a 90s tsc spawn. Inconclusive
-        // results never block.
-        let typecheckError = null;
-        if (missingFiles.length === 0 && leftoverFiles.length === 0) {
-            const root = findTypecheckRoot(this.baseDir, existingFiles);
-            if (root) {
-                try {
-                    typecheckError = await runTypecheck(root);
-                }
-                catch {
-                    typecheckError = null;
-                }
-            }
-        }
         const doneSteps = plan.steps.filter((s) => s.status === "done").length;
-        // done + skipped are both deliberate terminal states: `done` claims the
-        // work, `skipped` documents a decision that the step is not needed (the
-        // deliverable gate's documented escape hatch). Neither is a lie the
-        // audit must catch — a plan with a legitimately skipped step must be
-        // able to pass (observed: skipped step 1 kept the task rejected forever).
-        const terminalSteps = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
         const totalSteps = plan.steps.length;
-        const auditedFiles = [...new Set([...createFiles, ...deleteFiles])];
         let massEditWarning = null;
-        if (auditedFiles.length > MASS_EDIT_THRESHOLD) {
+        if (uniqueFiles.length > MASS_EDIT_THRESHOLD) {
             massEditWarning = t("exec.mass_edit_warning", {
-                count: String(auditedFiles.length),
+                count: String(uniqueFiles.length),
             });
         }
-        const testsFailing = testRun !== null && !testRun.passed;
-        const typecheckFailing = typecheckError !== null;
-        const passed = missingFiles.length === 0 && leftoverFiles.length === 0 && !testsFailing && !typecheckFailing;
-        // A "Task complete ✓" summary for an unfinished plan is a lie the model
-        // reads as a green light (observed: audit gate injected "[✓] Task
-        // complete: 1/3 steps done" while the plan had 2 pending steps). The
-        // summary must only claim completion when every step is actually done.
-        const stepsPending = terminalSteps < totalSteps;
+        const passed = missingFiles.length === 0;
         let summary;
-        if (missingFiles.length > 0) {
-            summary = t("exec.audit_fail", {
-                done: doneSteps,
-                total: totalSteps,
-                files: missingFiles.length,
-            });
-        }
-        else if (leftoverFiles.length > 0) {
-            summary = t("exec.audit_leftovers", {
-                done: doneSteps,
-                total: totalSteps,
-                files: leftoverFiles.length,
-            });
-        }
-        else if (testsFailing) {
-            summary = t("exec.audit_fail_tests", {
-                done: doneSteps,
-                total: totalSteps,
-                failed: String(testRun.failed),
-                passed: String(testRun.passedCount),
-                detail: testRun.detail,
-            });
-        }
-        else if (typecheckFailing) {
-            summary = t("exec.audit_fail_typecheck", {
-                done: doneSteps,
-                total: totalSteps,
-                missing: String(missingFiles.length),
-                typeError: typecheckError,
-            });
-        }
-        else if (stepsPending) {
-            summary = t("exec.audit_pending", {
+        if (passed) {
+            summary = t("exec.audit_pass", {
                 done: doneSteps,
                 total: totalSteps,
+                files: existingFiles.length,
             });
         }
         else {
-            summary = t("exec.audit_pass", {
+            summary = t("exec.audit_fail", {
                 done: doneSteps,
                 total: totalSteps,
-                files: existingFiles.length,
+                files: missingFiles.length,
             });
         }
         return {
             passed,
             missingFiles,
-            leftoverFiles,
             createdFiles: existingFiles,
             modifiedFiles: [],
             summary,
             massEditWarning,
-            testRun,
-            typecheckError,
         };
     }
 }