@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/pred.ts

@@ -1,395 +0,0 @@
-/** 约束（Pred）：附着在项上的事实，可传播。 */
-
-import type { Term } from "./term.ts";
-import { termEquals, termToString, lit } from "./term.ts";
-
-export type PrimName = "number" | "string" | "boolean" | "bigint" | "symbol";
-
-export type Pred =
-  | { op: "true" }
-  | { op: "false" }
-  | { op: "eq"; a: Term; b: Term }
-  | { op: "ne"; a: Term; b: Term }
-  | { op: "lt"; a: Term; b: Term }
-  | { op: "le"; a: Term; b: Term }
-  | { op: "gt"; a: Term; b: Term }
-  | { op: "ge"; a: Term; b: Term }
-  | { op: "and"; args: Pred[] }
-  | { op: "or"; args: Pred[] }
-  | { op: "not"; arg: Pred }
-  | { op: "typeof"; t: Term; type: PrimName };
-
-export const pTrue: Pred = { op: "true" };
-export const pFalse: Pred = { op: "false" };
-
-export const eq = (a: Term, b: Term): Pred => ({ op: "eq", a, b });
-export const ne = (a: Term, b: Term): Pred => ({ op: "ne", a, b });
-export const lt = (a: Term, b: Term): Pred => ({ op: "lt", a, b });
-export const le = (a: Term, b: Term): Pred => ({ op: "le", a, b });
-export const gt = (a: Term, b: Term): Pred => ({ op: "gt", a, b });
-export const ge = (a: Term, b: Term): Pred => ({ op: "ge", a, b });
-export const ptypeof = (t: Term, type: PrimName): Pred => ({
-  op: "typeof",
-  t,
-  type,
-});
-
-export function and(...preds: Pred[]): Pred {
-  const flat: Pred[] = [];
-  for (const p of preds) {
-    if (p.op === "true") continue;
-    if (p.op === "false") return pFalse;
-    if (p.op === "and") flat.push(...p.args);
-    else flat.push(p);
-  }
-  if (flat.length === 0) return pTrue;
-  if (flat.length === 1) return flat[0]!;
-  return { op: "and", args: flat };
-}
-
-export function or(...preds: Pred[]): Pred {
-  const flat: Pred[] = [];
-  for (const p of preds) {
-    if (p.op === "false") continue;
-    if (p.op === "true") return pTrue;
-    if (p.op === "or") flat.push(...p.args);
-    else flat.push(p);
-  }
-  if (flat.length === 0) return pFalse;
-  if (flat.length === 1) return flat[0]!;
-  return { op: "or", args: flat };
-}
-
-export function not(p: Pred): Pred {
-  if (p.op === "true") return pFalse;
-  if (p.op === "false") return pTrue;
-  if (p.op === "not") return p.arg;
-  return { op: "not", arg: p };
-}
-
-export function predEquals(a: Pred, b: Pred): boolean {
-  if (a.op !== b.op) return false;
-  switch (a.op) {
-    case "true":
-    case "false":
-      return true;
-    case "eq":
-    case "ne":
-    case "lt":
-    case "le":
-    case "gt":
-    case "ge":
-      return (
-        b.op === a.op &&
-        termEquals(a.a, (b as typeof a).a) &&
-        termEquals(a.b, (b as typeof a).b)
-      );
-    case "and":
-    case "or":
-      return (
-        (b.op === "and" || b.op === "or") &&
-        a.args.length === (b as typeof a).args.length &&
-        a.args.every((x, i) => predEquals(x, (b as typeof a).args[i]!))
-      );
-    case "not":
-      return b.op === "not" && predEquals(a.arg, b.arg);
-    case "typeof":
-      return (
-        b.op === "typeof" &&
-        a.type === b.type &&
-        termEquals(a.t, b.t)
-      );
-  }
-}
-
-export function predToString(p: Pred): string {
-  switch (p.op) {
-    case "true":
-      return "true";
-    case "false":
-      return "false";
-    case "eq":
-      return `${termToString(p.a)} = ${termToString(p.b)}`;
-    case "ne":
-      return `${termToString(p.a)} ≠ ${termToString(p.b)}`;
-    case "lt":
-      return `${termToString(p.a)} < ${termToString(p.b)}`;
-    case "le":
-      return `${termToString(p.a)} ≤ ${termToString(p.b)}`;
-    case "gt":
-      return `${termToString(p.a)} > ${termToString(p.b)}`;
-    case "ge":
-      return `${termToString(p.a)} ≥ ${termToString(p.b)}`;
-    case "and":
-      return p.args.map(predToString).join(" ∧ ");
-    case "or":
-      return `(${p.args.map(predToString).join(" ∨ ")})`;
-    case "not":
-      return `¬(${predToString(p.arg)})`;
-    case "typeof":
-      return `typeof ${termToString(p.t)} = "${p.type}"`;
-  }
-}
-
-/** 把 pred 里的 Term 用 subst 替换（用于 bound 变量重命名等） */
-export function substPred(p: Pred, subst: (t: Term) => Term): Pred {
-  switch (p.op) {
-    case "true":
-    case "false":
-      return p;
-    case "eq":
-    case "ne":
-    case "lt":
-    case "le":
-    case "gt":
-    case "ge":
-      return { ...p, a: subst(p.a), b: subst(p.b) } as Pred;
-    case "and":
-    case "or":
-      return { ...p, args: p.args.map((x) => substPred(x, subst)) };
-    case "not":
-      return { op: "not", arg: substPred(p.arg, subst) };
-    case "typeof":
-      return { op: "typeof", t: subst(p.t), type: p.type };
-  }
-}
-
-/** 收集 pred 中出现的自由变量 */
-export function predVars(p: Pred): Set<string> {
-  const acc = new Set<string>();
-  const walkTerm = (t: Term): void => {
-    if (t.op === "var") acc.add(t.id);
-    if (t.op === "app") t.args.forEach(walkTerm);
-  };
-  const walk = (p: Pred): void => {
-    switch (p.op) {
-      case "true":
-      case "false":
-        return;
-      case "eq":
-      case "ne":
-      case "lt":
-      case "le":
-      case "gt":
-      case "ge":
-        walkTerm(p.a);
-        walkTerm(p.b);
-        return;
-      case "and":
-      case "or":
-        p.args.forEach(walk);
-        return;
-      case "not":
-        walk(p.arg);
-        return;
-      case "typeof":
-        walkTerm(p.t);
-        return;
-    }
-  };
-  walk(p);
-  return acc;
-}
-
-/** 约束环境 Φ：Pred 的合取 */
-export type Phi = Pred;
-
-export const emptyPhi: Phi = pTrue;
-export const phiAnd = and;
-
-/** 简单蕴含：在区间/字面量可判定范围内判断 Φ ⊢ pred */
-export function implies(phi: Phi, pred: Pred): boolean {
-  if (pred.op === "true") return true;
-  if (pred.op === "false") return false;
-  if (phi.op === "true") {
-    // 无约束时，纯字面量比较可判定
-    return decideLiteralPred(pred) === true;
-  }
-  if (predEquals(phi, pred)) return true;
-  if (phi.op === "and" && phi.args.some((c) => predEquals(c, pred))) return true;
-
-  // 尝试从 Φ 提取同一 term 的界，做区间蕴含
-  const bounds = extractBounds(phi);
-  const implied = impliesViaBounds(pred, bounds);
-  if (implied !== undefined) return implied;
-
-  // 字面量可判定
-  const litAns = decideLiteralPred(pred);
-  if (litAns !== undefined) return litAns;
-  return false;
-}
-
-type Bounds = {
-  /** term key → { lo 独占? hi 独占? } */
-  lo: Map<string, { bound: number; strict: boolean }>;
-  hi: Map<string, { bound: number; strict: boolean }>;
-};
-
-function termKey(t: Term): string {
-  return termToString(t);
-}
-
-function extractBounds(phi: Phi): Bounds {
-  const lo = new Map<string, { bound: number; strict: boolean }>();
-  const hi = new Map<string, { bound: number; strict: boolean }>();
-  const conjs: Pred[] = phi.op === "and" ? phi.args : [phi];
-  for (const c of conjs) {
-    if (c.op === "gt" || c.op === "ge") {
-      // a > b  or a ≥ b，且 b 是字面量
-      if (c.b.op === "lit" && typeof c.b.value === "number") {
-        const k = termKey(c.a);
-        const cur = lo.get(k);
-        const next = { bound: c.b.value, strict: c.op === "gt" };
-        if (!cur || next.bound > cur.bound || (next.bound === cur.bound && next.strict)) {
-          lo.set(k, next);
-        }
-      }
-      // 反向：字面量 > term  ⇒ term < 字面量
-      if (c.a.op === "lit" && typeof c.a.value === "number") {
-        const k = termKey(c.b);
-        const cur = hi.get(k);
-        const next = { bound: c.a.value, strict: c.op === "gt" };
-        if (!cur || next.bound < cur.bound || (next.bound === cur.bound && next.strict)) {
-          hi.set(k, next);
-        }
-      }
-    }
-    if (c.op === "lt" || c.op === "le") {
-      if (c.b.op === "lit" && typeof c.b.value === "number") {
-        const k = termKey(c.a);
-        const cur = hi.get(k);
-        const next = { bound: c.b.value, strict: c.op === "lt" };
-        if (!cur || next.bound < cur.bound || (next.bound === cur.bound && next.strict)) {
-          hi.set(k, next);
-        }
-      }
-      if (c.a.op === "lit" && typeof c.a.value === "number") {
-        const k = termKey(c.b);
-        const cur = lo.get(k);
-        const next = { bound: c.a.value, strict: c.op === "lt" };
-        if (!cur || next.bound > cur.bound || (next.bound === cur.bound && next.strict)) {
-          lo.set(k, next);
-        }
-      }
-    }
-    if (c.op === "eq" && c.a.op === "var" && c.b.op === "lit" && typeof c.b.value === "number") {
-      lo.set(c.a.id, { bound: c.b.value, strict: false });
-      hi.set(c.a.id, { bound: c.b.value, strict: false });
-    }
-  }
-  return { lo, hi };
-}
-
-/**
- * 用区间界蕴含原子比较。
- * 支持：term > n / ≥ n / < n / ≤ n，以及 term+lit 形式的简单平移。
- * 返回 undefined 表示无法判定。
- */
-function impliesViaBounds(pred: Pred, bounds: Bounds): boolean | undefined {
-  if (
-    pred.op !== "gt" &&
-    pred.op !== "ge" &&
-    pred.op !== "lt" &&
-    pred.op !== "le"
-  ) {
-    return undefined;
-  }
-  // 归一：只处理 term ⊕ lit 比较 lit 的情况
-  const left = pred.a;
-  const right = pred.b;
-  if (right.op !== "lit" || typeof right.value !== "number") return undefined;
-  const n = right.value;
-
-  // 直接 term
-  if (left.op === "var") {
-    return cmpVar(left.id, pred.op, n, bounds);
-  }
-  // term = x + k
-  if (left.op === "app" && left.fn === "+" && left.args.length === 2) {
-    const [a, b] = left.args as [Term, Term];
-    if (a.op === "var" && b.op === "lit" && typeof b.value === "number") {
-      // x + k  op  n  ⟺  x  op  (n - k)
-      return cmpVar(a.id, pred.op, n - b.value, bounds);
-    }
-    if (b.op === "var" && a.op === "lit" && typeof a.value === "number") {
-      return cmpVar(b.id, pred.op, n - a.value, bounds);
-    }
-  }
-  // 纯字面量已在外层处理
-  return undefined;
-}
-
-function cmpVar(
-  id: string,
-  op: "gt" | "ge" | "lt" | "le",
-  n: number,
-  bounds: Bounds,
-): boolean | undefined {
-  const lo = bounds.lo.get(id);
-  const hi = bounds.hi.get(id);
-  // x > n：需要 lo ≥ n（若 strict lo 则 lo ≥ n；若 lo = n 且 non-strict 则 x≥n 不能推出 x>n）
-  if (op === "gt") {
-    if (!lo) return undefined;
-    if (lo.strict) return lo.bound >= n;
-    return lo.bound > n;
-  }
-  if (op === "ge") {
-    if (!lo) return undefined;
-    return lo.bound >= n;
-  }
-  if (op === "lt") {
-    if (!hi) return undefined;
-    if (hi.strict) return hi.bound <= n;
-    return hi.bound < n;
-  }
-  if (op === "le") {
-    if (!hi) return undefined;
-    return hi.bound <= n;
-  }
-  return undefined;
-}
-
-function decideLiteralPred(pred: Pred): boolean | undefined {
-  if (
-    pred.op === "eq" ||
-    pred.op === "ne" ||
-    pred.op === "lt" ||
-    pred.op === "le" ||
-    pred.op === "gt" ||
-    pred.op === "ge"
-  ) {
-    if (pred.a.op === "lit" && pred.b.op === "lit") {
-      const a = pred.a.value;
-      const b = pred.b.value;
-      switch (pred.op) {
-        case "eq":
-          return a === b;
-        case "ne":
-          return a !== b;
-        case "lt":
-          return typeof a === "number" && typeof b === "number" && a < b;
-        case "le":
-          return typeof a === "number" && typeof b === "number" && a <= b;
-        case "gt":
-          return typeof a === "number" && typeof b === "number" && a > b;
-        case "ge":
-          return typeof a === "number" && typeof b === "number" && a >= b;
-      }
-    }
-  }
-  return undefined;
-}
-
-/** 便捷：数字下界 */
-export function gtNum(term: Term, n: number): Pred {
-  return gt(term, lit(n));
-}
-export function geNum(term: Term, n: number): Pred {
-  return ge(term, lit(n));
-}
-export function ltNum(term: Term, n: number): Pred {
-  return lt(term, lit(n));
-}
-export function leNum(term: Term, n: number): Pred {
-  return le(term, lit(n));
-}

package/src/algebra/refine.ts

@@ -1,227 +0,0 @@
-/**
- * 精化契约解析：唯一形态
- *
- *   @nudo:refine <param> <constraint>    参数精化（挂入口 Abs，参与运算）
- *   @nudo:refine return <constraint>     返回精化（推断返回值 ⊭ 时红）
- *
- * 不叫 requires：那只是「校验挡板」。
- * refine 表示约束是类型的一部分——Abs = shape × term × **pred** × conf，
- * pred 会流入代数（x>0 ⇒ x+1>1），不只是调用点挡一下。
- *
- * constraint 来自 *.nudo.js 导出的模板（number().gt(0) 等），
- * 由 /// @nudo:import { delay } from "./delay.nudo.js" 引入。
- * 不支持写 `x > 0`（绑死参数名）。
- * 不用 JSDoc @param/@return：那是类型注解语法。
- */
-
-import type { Pred } from "./pred.ts";
-import { v as termVar } from "./term.ts";
-import { parseSource } from "./parse-source.ts";
-import {
-  type NudoConstraint,
-  isNudoConstraint,
-  instantiateConstraint,
-  number,
-  string as stringC,
-  boolean as booleanC,
-  shape,
-  array,
-} from "./constraint.ts";
-
-/** `/// @nudo:import { delay, percent } from "./delay.nudo.js"` */
-export type NamedImport = { names: string[]; spec: string };
-
-export function extractNudoImports(source: string): NamedImport[] {
-  const out: NamedImport[] = [];
-  // named: import { a, b as c } from "..."
-  const named = /@nudo:import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
-  let m: RegExpExecArray | null;
-  while ((m = named.exec(source))) {
-    const names = m[1]!
-      .split(",")
-      .map((s) => s.trim())
-      .filter(Boolean)
-      .map((s) => s.split(/\s+as\s+/).pop()!.trim());
-    out.push({ names, spec: m[2]! });
-  }
-  // 兼容 namespace（仍支持）
-  const ns = /@nudo:import\s+\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']/g;
-  while ((m = ns.exec(source))) {
-    out.push({ names: [`*${m[1]}`], spec: m[2]! });
-  }
-  return out;
-}
-
-/**
- * 执行 *.nudo.js（真实 JS + 我们的构建器）。
- * 把 export const 改写成 const，末尾 return { names }。
- */
-export function execNudoModule(src: string): Record<string, unknown> {
-  const names = [...src.matchAll(/export\s+const\s+(\w+)/g)].map((m) => m[1]!);
-  let body = src.replace(/export\s+const\b/g, "const");
-  // 去掉 import { number } from "..." —— 用注入参数
-  body = body.replace(/^\s*import\s*\{[^}]*\}\s*from\s*["'][^"']+["'];?\s*$/gm, "");
-  body = body.replace(/^\s*import\s+\*\s+as\s+\w+\s+from\s*["'][^"']+["'];?\s*$/gm, "");
-  body += `\nreturn { ${names.join(", ")} };`;
-  const fn = new Function("number", "string", "boolean", "shape", "array", body);
-  return fn(number, stringC, booleanC, shape, array) as Record<string, unknown>;
-}
-
-export type RefineResolveOpts = {
-  loadModule?: (spec: string, fromFile: string) => string | undefined;
-  fromFile?: string;
-};
-
-/** *.nudo.js 构建器执行结果（同内容只 new Function 一次） */
-const nudoModuleExecCache = new Map<string, Record<string, unknown>>();
-const MAX_NUDO_MODULE_EXEC = 64;
-
-function execNudoModuleCached(src: string): Record<string, unknown> {
-  const hit = nudoModuleExecCache.get(src);
-  if (hit !== undefined) {
-    nudoModuleExecCache.delete(src);
-    nudoModuleExecCache.set(src, hit);
-    return hit;
-  }
-  const out = execNudoModule(src);
-  if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
-    const oldest = nudoModuleExecCache.keys().next().value;
-    if (oldest !== undefined) nudoModuleExecCache.delete(oldest);
-  }
-  nudoModuleExecCache.set(src, out);
-  return out;
-}
-
-export function resetNudoModuleExecCache(): void {
-  nudoModuleExecCache.clear();
-}
-
-/** 从导入收集 name → NudoConstraint */
-function collectConstraints(
-  source: string,
-  opts: RefineResolveOpts,
-): Map<string, NudoConstraint> {
-  const map = new Map<string, NudoConstraint>();
-  const imports = extractNudoImports(source);
-  for (const imp of imports) {
-    if (!opts.loadModule || !opts.fromFile) continue;
-    const src = opts.loadModule(imp.spec, opts.fromFile);
-    if (!src) continue;
-    let exports: Record<string, unknown>;
-    try {
-      exports = execNudoModuleCached(src);
-    } catch {
-      continue;
-    }
-    for (const name of imp.names) {
-      if (name.startsWith("*")) continue; // namespace 暂不展开
-      const v = exports[name];
-      if (isNudoConstraint(v)) map.set(name, v);
-    }
-  }
-  return map;
-}
-
-/** 从源码抽函数上的 @nudo:refine 行 */
-function extractRefineLines(source: string, fnName: string): string[] {
-  const fnRe = new RegExp(
-    `(?:export\\s+default\\s+)?(?:function\\s+${fnName}\\b|const\\s+${fnName}\\s*=)`,
-  );
-  const m = source.match(fnRe);
-  if (!m || m.index === undefined) return [];
-  const before = source.slice(0, m.index);
-  const lines = before.split("\n");
-  const reqs: string[] = [];
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i]!.trim();
-    if (line === "" || line === "*/") continue;
-    if (line.startsWith("*") || line.startsWith("/*") || line.startsWith("//")) {
-      const rm = line.match(/@nudo:refine\s+(.+)$/);
-      if (rm) reqs.unshift(rm[1]!.trim().replace(/\*\/$/, "").trim());
-      continue;
-    }
-    break;
-  }
-  return reqs;
-}
-
-/**
- * 解析 `ms delay` / `n percent` → [param, Pred]
- * 多条用 && 或换行连接。
- * 同时保留原始 NudoConstraint（shape 字段检查用）。
- */
-export type RefineEntry = {
-  param: string;
-  pred: Pred;
-  constraint: NudoConstraint;
-};
-
-export function extractRefinesFromSource(
-  source: string,
-  fnName: string,
-  opts: RefineResolveOpts = {},
-): RefineEntry[] {
-  // 快路径：整文件无 @nudo:refine 时免 regex 扫全文（after-edit 批量 check）
-  if (!source.includes("@nudo:refine")) return [];
-  const constraints = collectConstraints(source, opts);
-  const out: RefineEntry[] = [];
-  for (const line of extractRefineLines(source, fnName)) {
-    const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
-    for (const part of parts) {
-      const m = part.match(/^(\w+)\s+(\w+)$/);
-      if (!m) continue;
-      const [, param, cName] = m;
-      // return 是后置目标，不进参数精化
-      if (param === "return") continue;
-      const c = constraints.get(cName!);
-      if (!c) continue;
-      out.push({
-        param: param!,
-        pred: instantiateConstraint(c, param!),
-        constraint: c,
-      });
-    }
-  }
-  return out;
-}
-
-/** refine 参数 → 带约束模板的下标表（shape 检查用） */
-export function refineToIndexedFull(
-  source: string,
-  fnName: string,
-  paramNames: string[],
-  opts: RefineResolveOpts = {},
-): Array<[number, RefineEntry]> {
-  const raw = extractRefinesFromSource(source, fnName, opts);
-  const out: Array<[number, RefineEntry]> = [];
-  for (const item of raw) {
-    const idx = paramNames.indexOf(item.param);
-    if (idx >= 0) out.push([idx, item]);
-  }
-  return out;
-}
-
-/**
- * 解析 `@nudo:refine return positive` → 返回精化。
- * 返回 undefined = 无声明（不猜后置）。
- */
-export function extractRefineReturnFromSource(
-  source: string,
-  fnName: string,
-  opts: RefineResolveOpts = {},
-): { name: string; constraint: NudoConstraint } | undefined {
-  if (!source.includes("@nudo:refine")) return undefined;
-  const constraints = collectConstraints(source, opts);
-  for (const line of extractRefineLines(source, fnName)) {
-    const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
-    for (const part of parts) {
-      const m = part.match(/^return\s+(\w+)$/);
-      if (!m) continue;
-      const cName = m[1]!;
-      const c = constraints.get(cName);
-      if (!c) continue;
-      return { name: cName, constraint: c };
-    }
-  }
-  return undefined;
-}

package/src/algebra/stable-source-key.ts

@@ -1,81 +0,0 @@
-/**
- * Analysis-stable source key: strip trailing noise that cannot affect types.
- * Keeps every line that may carry @nudo directives.
- *
- * Fast path: already-stable sources return the same string identity (O(1)
- * compare in B-path / analysis caches when the caller reuses the buffer).
- */
-export function stableAnalyzeKeySource(source: string): string {
-  // Scan back over trailing whitespace/newlines (usually a few chars).
-  let end = source.length;
-  while (end > 0) {
-    const ch = source.charCodeAt(end - 1);
-    if (ch === 10 || ch === 13 || ch === 32 || ch === 9) {
-      end--;
-      continue;
-    }
-    break;
-  }
-  const lineStart = source.lastIndexOf("\n", end - 1) + 1;
-  const lastLine = source.slice(lineStart, end);
-  const trimmedLast = lastLine.trim();
-  // Last non-empty line is real code → normalize trailing whitespace only,
-  // then still try stripping a trailing block comment below.
-  if (trimmedLast !== "" && !trimmedLast.startsWith("//") && !trimmedLast.startsWith("/*")) {
-    let body = source.slice(0, end);
-    if (body.endsWith("*/")) {
-      body = stripTrailingBlockComments(body);
-      return body + "\n";
-    }
-    const after = source.slice(end);
-    if (after === "" || after === "\n") return source;
-    return source.slice(0, end) + "\n";
-  }
-
-  const lines = source.split("\n");
-  while (lines.length > 0) {
-    const last = lines[lines.length - 1]!;
-    if (last.trim() === "") {
-      lines.pop();
-      continue;
-    }
-    if (last.trimStart().startsWith("//") && !last.includes("@nudo")) {
-      lines.pop();
-      continue;
-    }
-    // Multi-line trailing block comment (/* ... */) without @nudo.
-    if (last.trim() === "*/" || last.trimStart().startsWith("/*")) {
-      const joined = stripTrailingBlockComments(lines.join("\n"));
-      const stripped = joined.split("\n");
-      if (stripped.length < lines.length) {
-        lines.length = 0;
-        lines.push(...stripped);
-        continue;
-      }
-    }
-    break;
-  }
-  let body = lines.join("\n").replace(/\s+$/, "");
-  body = stripTrailingBlockComments(body);
-  return body + "\n";
-}
-
-/**
- * Strip trailing `/* ... *\/` comments that sit alone on their line(s) and
- * carry no @nudo directive. Heuristic: `/*` must start a line (after indent)
- * so we do not cut inside strings. Returns body without a trailing newline.
- */
-function stripTrailingBlockComments(body: string): string {
-  let t = body.replace(/\s+$/, "");
-  while (t.endsWith("*/")) {
-    const start = t.lastIndexOf("/*");
-    if (start < 0) break;
-    const block = t.slice(start);
-    if (block.includes("@nudo")) break;
-    const before = t.slice(0, start);
-    const lineStart = before.lastIndexOf("\n") + 1;
-    if (before.slice(lineStart).trim() !== "") break;
-    t = before.replace(/\s+$/, "");
-  }
-  return t;
-}