@deftai/directive-core 0.74.0 → 0.76.0

package/dist/cache/operations.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { pyRepr } from "../scm/py-format.js";
 import { ALLOWED_SOURCES, REPO_RE, SOURCE_TTL_SECONDS } from "./constants.js";
 import { CacheCapBreachedError, CacheError, CacheNotFoundError, CacheValidationError, } from "./errors.js";
@@ -10,6 +11,15 @@ import { enforceCaps, predictEvictionSet, resolveCaps, } from "./quota.js";
 import { flagsForMeta, SCANNER_VERSION, scan } from "./scanner.js";
 import { addSeconds, parseIso, systemClock, utcIso } from "./time.js";
 import { validateMeta } from "./validate.js";
+export { ProjectionContainmentError as CacheContainmentError };
+/** Refuse symlink-escaping `.deft-cache` before mkdir/read/write (#2470). */
+function assertWritableCachePath(cacheRoot, ...segments) {
+    const cacheAbs = resolve(cacheRoot);
+    const projectDir = dirname(cacheAbs);
+    const target = segments.length > 0 ? join(cacheAbs, ...segments) : cacheAbs;
+    assertProjectionContained(projectDir, target);
+    return target;
+}
 function renderContent(source, raw) {
     if (source === "github-issue") {
         const number = raw.number;
@@ -82,6 +92,7 @@ export function cachePut(source, key, raw, options = {}) {
     }
     const expires = addSeconds(fetched, ttl);
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const edir = entryDir(source, key, cacheRoot);
     const rawText = pythonJsonDump(raw);
     const rawSize = Buffer.byteLength(rawText, "utf8");
@@ -182,6 +193,7 @@ export function cachePut(source, key, raw, options = {}) {
 export function cacheGet(source, key, options = {}) {
     const clock = options.clock ?? systemClock;
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const allowStale = options.allowStale ?? true;
     const edir = entryDir(source, key, cacheRoot);
     const metaRelPath = `${source}/${key}/meta.json`;
@@ -220,6 +232,7 @@ export function cacheInvalidate(source, key, options = {}) {
     const clock = options.clock ?? systemClock;
     validateKey(source, key);
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const edir = entryDir(source, key, cacheRoot);
     const existed = existsSync(edir);
     if (existed)
@@ -252,6 +265,7 @@ export function cachePrune(options = {}) {
         throw new CacheError(`--older-than-days must be >= 0 (got ${JSON.stringify(olderThanDays)})`);
     }
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     if (!existsSync(cacheRoot))
         return [];
     const cutoff = addSeconds(clock.now(), -olderThanDays * 24 * 60 * 60);
@@ -313,6 +327,7 @@ function collectMetaPathsUnder(srcRoot) {
 export function cachePruneToCap(options = {}) {
     const clock = options.clock ?? systemClock;
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const resolved = options.caps ?? resolveCaps();
     if (!resolved.maxBytes && !resolved.maxEntries)
         return [];

package/dist/content-contracts/skills/helpers.d.ts

@@ -19,6 +19,5 @@ export declare function listSkillMdFiles(): string[];
 export declare const RFC2119_LEGEND = "!=MUST, ~=SHOULD";
 export declare const PLATFORM_DETECTION_HEADING = "## Platform Detection";
 export declare const USER_MD_GATE_HEADING = "## USER.md Gate";
-export declare const DEPRECATED_SKILL_REDIRECT_STUBS: Set<string>;
 export declare const REQUIRED_OSES: Set<string>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/content-contracts/skills/helpers.js

@@ -21,7 +21,7 @@ export function resolveRepoPath(relPath) {
     return repoPath(relPath);
 }
 export function readRepoFile(relPath) {
-    return readFileSync(resolveRepoPath(relPath), "utf8");
+    return readFileSync(resolveRepoPath(relPath), "utf8").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 export function repoFileExists(relPath) {
     return existsSync(resolveRepoPath(relPath));
@@ -59,15 +59,5 @@ export function listSkillMdFiles() {
 export const RFC2119_LEGEND = "!=MUST, ~=SHOULD";
 export const PLATFORM_DETECTION_HEADING = "## Platform Detection";
 export const USER_MD_GATE_HEADING = "## USER.md Gate";
-export const DEPRECATED_SKILL_REDIRECT_STUBS = new Set([
-    "deft-build",
-    "deft-interview",
-    "deft-pre-pr",
-    "deft-review-cycle",
-    "deft-roadmap-refresh",
-    "deft-setup",
-    "deft-swarm",
-    "deft-sync",
-]);
 export const REQUIRED_OSES = new Set(["darwin", "linux", "windows"]);
 //# sourceMappingURL=helpers.js.map

package/dist/content-contracts/skills/skill-frontmatter.js

@@ -4,7 +4,14 @@ import { REPO_ROOT, REQUIRED_OSES } from "./helpers.js";
 export { REQUIRED_OSES };
 const OS_LINE = /^os\s*:\s*\[(?<body>[^\]]*)\]\s*$/m;
 const OS_TOKEN = /['"]([^'"]+)['"]/g;
-const EXCLUDED_PARTS = new Set([".git", ".venv", "venv", "node_modules", "__pycache__"]);
+const EXCLUDED_PARTS = new Set([
+    ".git",
+    ".venv",
+    "venv",
+    "node_modules",
+    "__pycache__",
+    ".pytest_cache",
+]);
 function frontmatter(text) {
     if (!text.startsWith("---")) {
         return null;

package/dist/content-contracts/standards/_helpers.js

@@ -27,10 +27,12 @@ export function resolveContentPath(relPath) {
     return join(root, relPath);
 }
 export function readText(relPath) {
-    return readFileSync(resolveContentPath(relPath), { encoding: "utf8" });
+    return readFileSync(resolveContentPath(relPath), { encoding: "utf8" })
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n");
 }
 export function readAbs(absPath) {
-    return readFileSync(absPath, { encoding: "utf8" });
+    return readFileSync(absPath, { encoding: "utf8" }).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 export function pathExists(relPath) {
     return existsSync(resolveContentPath(relPath));

package/dist/content-contracts/standards/_taskfile-helpers.d.ts

@@ -1,4 +1,6 @@
 export declare function taskYamlFiles(): string[];
+/** Normalize CRLF so Taskfile parsers do not treat lone `\r` lines as section exits (#2467). */
+export declare function normalizeYamlNewlines(text: string): string;
 export declare function iterTaskBlocks(text: string): Array<{
     name: string;
     start: number;

package/dist/content-contracts/standards/_taskfile-helpers.js

@@ -10,8 +10,12 @@ export function taskYamlFiles() {
         .map((f) => join(dir, f))
         .sort();
 }
+/** Normalize CRLF so Taskfile parsers do not treat lone `\r` lines as section exits (#2467). */
+export function normalizeYamlNewlines(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
 export function iterTaskBlocks(text) {
-    const lines = text.split("\n");
+    const lines = normalizeYamlNewlines(text).split("\n");
     const taskPositions = [];
     let inTasksSection = false;
     for (let idx = 0; idx < lines.length; idx += 1) {
@@ -43,19 +47,21 @@ export function iterTaskBlocks(text) {
     return blocks;
 }
 export function blockBody(text, start, end) {
-    return text.split("\n").slice(start, end).join("\n");
+    return normalizeYamlNewlines(text).split("\n").slice(start, end).join("\n");
 }
 export function nonCommentLines(block) {
-    return block.split("\n").filter((ln) => !ln.trimStart().startsWith("#"));
+    return normalizeYamlNewlines(block)
+        .split("\n")
+        .filter((ln) => !ln.trimStart().startsWith("#"));
 }
 export function cachingKeyOnLine(line) {
     const m = line.match(CACHING_KEY);
     return m?.[1] ?? null;
 }
 export function readTaskfile(name) {
-    return readFileSync(join(repoRoot(), "tasks", name), { encoding: "utf8" });
+    return normalizeYamlNewlines(readFileSync(join(repoRoot(), "tasks", name), { encoding: "utf8" }));
 }
 export function readRoot(name) {
-    return readFileSync(join(repoRoot(), "tasks", "..", name), { encoding: "utf8" });
+    return normalizeYamlNewlines(readFileSync(join(repoRoot(), "tasks", "..", name), { encoding: "utf8" }));
 }
 //# sourceMappingURL=_taskfile-helpers.js.map

package/dist/doctor/doctor-state.js

@@ -1,4 +1,5 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 import { CLEAN_WINDOW_HOURS, DIRTY_WINDOW_HOURS, ENV_STATE_PATH } from "./constants.js";
@@ -7,7 +8,7 @@ export function statePath(projectRoot) {
     const override = process.env[ENV_STATE_PATH]?.trim();
     if (override) {
         return override.startsWith("~")
-            ? join(process.env.HOME ?? projectRoot, override.slice(1))
+            ? join(homedir(), override.slice(1).replace(/^[\\/]/, ""))
             : override;
     }
     return resolveTriageCachePath(projectRoot, STATE_FILENAME);

package/dist/doctor/paths.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFT_REPO_POSITIVE_MARKERS } from "./constants.js";
@@ -8,7 +9,7 @@ export function resolvePath(pathStr, cwd = process.cwd()) {
         return cwd;
     }
     const expanded = pathStr.startsWith("~")
-        ? join(process.env.HOME ?? cwd, pathStr.slice(1))
+        ? join(homedir(), pathStr.slice(1).replace(/^[\\/]/, ""))
         : pathStr;
     return resolve(cwd, expanded);
 }

package/dist/eval-health-relocation/evaluate.d.ts

@@ -0,0 +1,71 @@
+import { type HealthReport } from "../eval/health.js";
+export type OutputStream = "stdout" | "stderr" | "none";
+/** Glob patterns that classify a change as epic #2369 rule-relocation (#2373). */
+export declare const RULE_RELOCATION_PATH_PATTERNS: readonly ["AGENTS.md", "content/templates/agents-entry.md", "content/skills/**/SKILL.md", "content/packs/**"];
+/** Committed no-regression baseline relative to `xbrief/.eval/`. */
+export declare const HEALTH_BASELINE_REL = "results/eval-health-baseline.json";
+/** Result of verify:eval-health-relocation; three-state exit contract. */
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+    /** True when the diff did not touch rule-relocation paths (gate skipped). */
+    readonly skipped?: boolean;
+}
+export interface EvaluateOptions {
+    readonly projectRoot?: string;
+    /** Git ref for `git diff --name-only` (CI / branch comparison). */
+    readonly baseRef?: string;
+    /** Use `git diff --cached --name-only` (pre-commit / staged). */
+    readonly staged?: boolean;
+    /** Explicit path list (tests / overrides). */
+    readonly paths?: readonly string[];
+    readonly quiet?: boolean;
+    /** Write the current eval:health report as the committed baseline. */
+    readonly seedBaseline?: boolean;
+    /** Test hook: override eval:health collection. */
+    readonly healthEvaluator?: (projectRoot: string) => HealthReport | null;
+}
+/** Validate a parsed baseline JSON object before use. */
+export declare function parseHealthBaseline(parsed: unknown): HealthReport | null;
+/** True when *path* matches a rule-relocation home. */
+export declare function isRuleRelocationPath(path: string): boolean;
+/** Classify a path list for rule-relocation coverage. */
+export declare function classifyRuleRelocationPaths(paths: readonly string[]): {
+    readonly isRelocation: boolean;
+    readonly matchedPaths: readonly string[];
+};
+/** Absolute path to the committed eval-health baseline snapshot. */
+export declare function healthBaselinePath(projectRoot: string): string;
+/** Read the committed baseline snapshot, if present. */
+export declare function readHealthBaseline(projectRoot: string): HealthReport | null;
+/** Persist a health report as the committed baseline (#2373 Wave 2 seed). */
+export declare function writeHealthBaseline(projectRoot: string, report: HealthReport): void;
+/** Collect changed paths from git (base ref or staged index). */
+export declare function collectChangedPaths(projectRoot: string, options: {
+    baseRef?: string;
+    staged?: boolean;
+}): string[] | {
+    error: string;
+};
+/**
+ * Detect eval:health regression against a committed baseline.
+ *
+ * Fail-closed rules (#2373):
+ * - score must not drop below baseline
+ * - gates that passed in the baseline must still pass
+ * - no new contradictory-gate ids beyond the baseline set
+ */
+export declare function detectHealthRegression(current: HealthReport, baseline: HealthReport): {
+    pass: boolean;
+    reasons: readonly string[];
+};
+/**
+ * Conditional fail-closed gate for epic #2369 rule-relocation PRs (#2373).
+ *
+ * Skips (exit 0) when the diff does not touch relocation homes. When relocation
+ * paths are present, requires eval:health no-regression against the committed
+ * baseline at `xbrief/.eval/results/eval-health-baseline.json`.
+ */
+export declare function evaluate(options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/eval-health-relocation/evaluate.js

@@ -0,0 +1,252 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { evaluateHealth } from "../eval/health.js";
+import { resolveEvalPath } from "../layout/resolve.js";
+import { matchAny } from "../orchestration/pathspec.js";
+/** Glob patterns that classify a change as epic #2369 rule-relocation (#2373). */
+export const RULE_RELOCATION_PATH_PATTERNS = [
+    "AGENTS.md",
+    "content/templates/agents-entry.md",
+    "content/skills/**/SKILL.md",
+    "content/packs/**",
+];
+/** Committed no-regression baseline relative to `xbrief/.eval/`. */
+export const HEALTH_BASELINE_REL = "results/eval-health-baseline.json";
+/** Validate a parsed baseline JSON object before use. */
+export function parseHealthBaseline(parsed) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    if (typeof record.score !== "number" || !Array.isArray(record.gates)) {
+        return null;
+    }
+    if (!Array.isArray(record.contradictions)) {
+        return null;
+    }
+    return parsed;
+}
+/** True when *path* matches a rule-relocation home. */
+export function isRuleRelocationPath(path) {
+    return matchAny(RULE_RELOCATION_PATH_PATTERNS, path);
+}
+/** Classify a path list for rule-relocation coverage. */
+export function classifyRuleRelocationPaths(paths) {
+    const matchedPaths = paths.filter(isRuleRelocationPath);
+    return { isRelocation: matchedPaths.length > 0, matchedPaths };
+}
+/** Absolute path to the committed eval-health baseline snapshot. */
+export function healthBaselinePath(projectRoot) {
+    return resolveEvalPath(projectRoot, HEALTH_BASELINE_REL);
+}
+/** Read the committed baseline snapshot, if present. */
+export function readHealthBaseline(projectRoot) {
+    const path = healthBaselinePath(projectRoot);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parseHealthBaseline(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist a health report as the committed baseline (#2373 Wave 2 seed). */
+export function writeHealthBaseline(projectRoot, report) {
+    const path = healthBaselinePath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
+}
+function gitNameOnlyDiff(projectRoot, args) {
+    try {
+        const stdout = execFileSync("git", ["-C", projectRoot, "diff", "--name-only", ...args], {
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch (err) {
+        return { error: String(err) };
+    }
+}
+/** Collect changed paths from git (base ref or staged index). */
+export function collectChangedPaths(projectRoot, options) {
+    if (options.staged) {
+        return gitNameOnlyDiff(projectRoot, ["--cached"]);
+    }
+    if (options.baseRef !== undefined && options.baseRef.length > 0) {
+        return gitNameOnlyDiff(projectRoot, [options.baseRef, "HEAD"]);
+    }
+    return [];
+}
+/**
+ * Detect eval:health regression against a committed baseline.
+ *
+ * Fail-closed rules (#2373):
+ * - score must not drop below baseline
+ * - gates that passed in the baseline must still pass
+ * - no new contradictory-gate ids beyond the baseline set
+ */
+export function detectHealthRegression(current, baseline) {
+    const reasons = [];
+    if (current.score < baseline.score) {
+        reasons.push(`framework health score dropped ${baseline.score}->${current.score}`);
+    }
+    const baselineGates = new Map(baseline.gates.filter((gate) => !gate.skipped).map((gate) => [gate.id, gate]));
+    for (const [id, baseGate] of baselineGates) {
+        if (!baseGate.pass) {
+            continue;
+        }
+        const currentGate = current.gates.find((gate) => gate.id === id && !gate.skipped);
+        if (currentGate === undefined) {
+            reasons.push(`gate '${id}' missing from current eval:health report`);
+            continue;
+        }
+        if (!currentGate.pass) {
+            reasons.push(`gate '${id}' regressed (baseline pass -> current fail)`);
+        }
+    }
+    const baselineContradictionIds = new Set(baseline.contradictions.map((c) => c.id));
+    for (const contradiction of current.contradictions) {
+        if (!baselineContradictionIds.has(contradiction.id)) {
+            reasons.push(`new contradictory gate '${contradiction.id}'`);
+        }
+    }
+    return { pass: reasons.length === 0, reasons };
+}
+function formatSkipMessage(matchedPaths) {
+    return ("✓ verify:eval-health-relocation: no rule-relocation paths in diff " +
+        `(checked ${RULE_RELOCATION_PATH_PATTERNS.length} patterns; ` +
+        `diff had ${matchedPaths.length} relocation match${matchedPaths.length === 1 ? "" : "es"}).`);
+}
+function formatPassMessage(score, matchedPaths) {
+    return (`✓ verify:eval-health-relocation: eval:health no-regression OK ` +
+        `(score=${score}/100; relocation paths: ${matchedPaths.join(", ")}).`);
+}
+function formatRegressionMessage(reasons, matchedPaths, baseline, current) {
+    const detail = reasons.map((reason) => `   - ${reason}`).join("\n");
+    return ("❌ verify:eval-health-relocation: eval:health regression on rule-relocation PR " +
+        `(#2373 / epic #2369).\n` +
+        `   Baseline score: ${baseline.score}/100; current: ${current.score}/100.\n` +
+        `   Matched relocation paths: ${matchedPaths.join(", ")}\n` +
+        `${detail}\n` +
+        "   Remediation: restore gate pass states / score, or bump the committed baseline\n" +
+        `   at ${HEALTH_BASELINE_REL} only after a deliberate, reviewed health change.\n` +
+        "   Run `task eval:health` for the full gate breakdown.");
+}
+function runHealthEvaluator(projectRoot, healthEvaluator) {
+    if (healthEvaluator !== undefined) {
+        return healthEvaluator(projectRoot);
+    }
+    const healthResult = evaluateHealth({
+        projectRoot,
+        persist: false,
+        frameworkSource: true,
+    });
+    return healthResult.report;
+}
+/**
+ * Conditional fail-closed gate for epic #2369 rule-relocation PRs (#2373).
+ *
+ * Skips (exit 0) when the diff does not touch relocation homes. When relocation
+ * paths are present, requires eval:health no-regression against the committed
+ * baseline at `xbrief/.eval/results/eval-health-baseline.json`.
+ */
+export function evaluate(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const quiet = options.quiet ?? false;
+    if (options.seedBaseline) {
+        const report = runHealthEvaluator(projectRoot, options.healthEvaluator);
+        if (report === null) {
+            return {
+                code: 2,
+                message: "❌ verify:eval-health-relocation: eval:health returned no report.",
+                stream: "stderr",
+            };
+        }
+        writeHealthBaseline(projectRoot, report);
+        return {
+            code: 0,
+            message: `✓ verify:eval-health-relocation: seeded baseline at ${HEALTH_BASELINE_REL} ` +
+                `(score=${report.score}/100).`,
+            stream: "stdout",
+        };
+    }
+    let paths;
+    if (options.paths !== undefined) {
+        paths = [...options.paths];
+    }
+    else if (options.baseRef !== undefined || options.staged) {
+        const collected = collectChangedPaths(projectRoot, {
+            baseRef: options.baseRef,
+            staged: options.staged,
+        });
+        if ("error" in collected) {
+            return {
+                code: 2,
+                message: "❌ verify:eval-health-relocation: could not read git diff " +
+                    `(project_root=${projectRoot}): ${collected.error}`,
+                stream: "stderr",
+            };
+        }
+        paths = collected;
+    }
+    else {
+        return { code: 0, message: "", stream: "none", skipped: true };
+    }
+    const { isRelocation, matchedPaths } = classifyRuleRelocationPaths(paths);
+    if (!isRelocation) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none", skipped: true };
+        }
+        return {
+            code: 0,
+            message: formatSkipMessage(matchedPaths),
+            stream: "stdout",
+            skipped: true,
+        };
+    }
+    const current = runHealthEvaluator(projectRoot, options.healthEvaluator);
+    if (current === null) {
+        return {
+            code: 2,
+            message: "❌ verify:eval-health-relocation: eval:health returned no report.",
+            stream: "stderr",
+        };
+    }
+    const baseline = readHealthBaseline(projectRoot);
+    if (baseline === null) {
+        return {
+            code: 2,
+            message: "❌ verify:eval-health-relocation: missing committed baseline " +
+                `at ${HEALTH_BASELINE_REL}.\n` +
+                "   Seed once with: task verify:eval-health-relocation -- --seed-baseline\n" +
+                "   (after `task eval:health` is green on master). Baseline seeding is intentional\n" +
+                "   and does not weaken verify:agents-md-budget.",
+            stream: "stderr",
+        };
+    }
+    const regression = detectHealthRegression(current, baseline);
+    if (!regression.pass) {
+        return {
+            code: 1,
+            message: formatRegressionMessage(regression.reasons, matchedPaths, baseline, current),
+            stream: "stderr",
+        };
+    }
+    if (quiet) {
+        return { code: 0, message: "", stream: "none" };
+    }
+    return {
+        code: 0,
+        message: formatPassMessage(current.score, matchedPaths),
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/eval-health-relocation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/eval-health-relocation/index.js

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.js.map