@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/hash-source.ts

@@ -1,27 +0,0 @@
-/**
- * Session-memo content key. Not cryptographic: dual 32-bit FNV-1a mix + length
- * keeps birthday collisions negligible for LRU-sized caches (hundreds of entries)
- * without paying for a full digest on every edit.
- */
-let lastHashSource: string | undefined;
-let lastHashOut: string | undefined;
-
-export function hashSource(s: string): string {
-  if (s === lastHashSource && lastHashOut !== undefined) return lastHashOut;
-  let h1 = 2166136261;
-  let h2 = 0x9e3779b9;
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    h1 ^= c;
-    h1 = Math.imul(h1, 16777619);
-    h2 = Math.imul(h2 ^ c, 16777619);
-  }
-  lastHashSource = s;
-  lastHashOut = `${(h1 >>> 0).toString(36)}-${(h2 >>> 0).toString(36)}_${s.length.toString(36)}`;
-  return lastHashOut;
-}
-
-export function resetHashSourceCache(): void {
-  lastHashSource = undefined;
-  lastHashOut = undefined;
-}

package/src/algebra/index.ts

@@ -1,34 +0,0 @@
-export * from "./term.ts";
-export * from "./pred.ts";
-export * from "./phi.ts";
-export * from "./abs.ts";
-export * from "./abs-fn.ts";
-export * from "./arithmetic.ts";
-export * from "./surface.ts";
-export * from "./builtins.ts";
-export * from "./methods.ts";
-export * from "./leak.ts";
-export * from "./objects.ts";
-export * from "./leq.ts";
-export * from "./ast-eval.ts";
-export * from "./format.ts";
-export * from "./generalize.ts";
-export * from "./diagnostics.ts";
-export * from "./template.ts";
-export * from "./language.ts";
-export * from "./parse-source.ts";
-export * from "./hash-source.ts";
-export * from "./stable-source-key.ts";
-export * from "./fn-fp.ts";
-export * from "./load-deps-fp.ts";
-export * from "./check.ts";
-export * from "./check-report.ts";
-export * from "./refine.ts";
-export * from "./constraint.ts";
-export * from "./inlay.ts";
-export * from "./denote.ts";
-export * from "./abs-modules.ts";
-export * from "./exec/index.ts";
-// modules/fs/path 属于 host（service/cli），不进代数
-export * from "./bridge.ts";
-

package/src/algebra/inlay.ts

@@ -1,198 +0,0 @@
-/**
- * Abs inlay hint：把无损约束内联到源码位置。
- * 不是 TS 风格 type annotation 复读，而是 term/pred/conf 的计算结果。
- */
-
-import type { Node, FunctionDeclaration } from "@babel/types";
-import { parseSource as parse } from "./parse-source.ts";
-import { generalizeFromAst } from "./generalize.ts";
-import { formatShape } from "./format.ts";
-import { predToString, type Pred } from "./pred.ts";
-import { termToString } from "./term.ts";
-
-export type AbsInlay = {
-  /** 1-based 行号 */
-  line: number;
-  /** 0-based 列（label 插入点） */
-  character: number;
-  label: string;
-  kind: "type" | "parameter";
-};
-
-function listFunctions(source: string): Array<{ name: string; node: Node }> {
-  const file = parse(source);
-  const out: Array<{ name: string; node: Node }> = [];
-  const visitDecl = (decl: Node): void => {
-    if (decl.type === "FunctionDeclaration" && (decl as FunctionDeclaration).id) {
-      const fd = decl as FunctionDeclaration;
-      out.push({ name: fd.id!.name, node: fd });
-    }
-    if (decl.type === "VariableDeclaration") {
-      for (const d of (decl as any).declarations ?? []) {
-        if (
-          d.id?.type === "Identifier" &&
-          d.init &&
-          (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")
-        ) {
-          out.push({ name: d.id.name, node: d.init });
-        }
-      }
-    }
-  };
-  for (const stmt of file.program.body) {
-    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
-      visitDecl(stmt.declaration as Node);
-    } else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
-      visitDecl(stmt.declaration as Node);
-    } else {
-      visitDecl(stmt);
-    }
-  }
-  return out;
-}
-
-/** 从函数体抽 param 的前置 Pred（与 check 同源逻辑的轻量版） */
-function paramPreds(
-  source: string,
-  fnName: string,
-  paramNames: string[],
-): Map<string, Pred[]> {
-  const byIndex = new Map<number, Pred[]>();
-  const file = parse(source);
-  const paramIndex = new Map(paramNames.map((p, i) => [p, i]));
-
-  const pushCmp = (
-    test: Record<string, unknown>,
-    consequent: Record<string, unknown> | undefined,
-  ): void => {
-    if (test?.type !== "BinaryExpression") return;
-    const left = test.left as { type?: string; name?: string };
-    const right = test.right as { type?: string; value?: number };
-    const op = test.operator as string;
-    if (
-      left?.type !== "Identifier" ||
-      !left.name ||
-      !paramIndex.has(left.name) ||
-      right?.type !== "NumericLiteral" ||
-      typeof right.value !== "number"
-    ) {
-      return;
-    }
-    const isReturnParam =
-      consequent?.type === "ReturnStatement" &&
-      (consequent.argument as { type?: string; name?: string })?.type === "Identifier" &&
-      (consequent.argument as { name?: string }).name === left.name;
-    if (!isReturnParam) return;
-    const idx = paramIndex.get(left.name)!;
-    const t = { op: "var" as const, id: left.name };
-    const b = { op: "lit" as const, value: right.value };
-    let pred: Pred | undefined;
-    if (op === ">") pred = { op: "gt", a: t, b };
-    else if (op === ">=") pred = { op: "ge", a: t, b };
-    else if (op === "<") pred = { op: "lt", a: t, b };
-    else if (op === "<=") pred = { op: "le", a: t, b };
-    if (!pred) return;
-    const list = byIndex.get(idx) ?? [];
-    list.push(pred);
-    byIndex.set(idx, list);
-  };
-
-  const visit = (n: unknown): void => {
-    if (!n || typeof n !== "object") return;
-    const obj = n as Record<string, unknown> & { type?: string };
-    if (obj.type === "IfStatement") {
-      const test = obj.test as Record<string, unknown>;
-      const consequent = obj.consequent as Record<string, unknown> | undefined;
-      pushCmp(test, consequent);
-      if (test?.type === "LogicalExpression" && test.operator === "&&") {
-        pushCmp(test.left as Record<string, unknown>, consequent);
-        pushCmp(test.right as Record<string, unknown>, consequent);
-      }
-    }
-    for (const key of Object.keys(obj)) {
-      if (key === "loc" || key === "start" || key === "end") continue;
-      const val = obj[key];
-      if (Array.isArray(val)) val.forEach(visit);
-      else if (val && typeof val === "object") visit(val);
-    }
-  };
-  visit(file);
-
-  const byName = new Map<string, Pred[]>();
-  for (const [idx, preds] of byIndex) {
-    const name = paramNames[idx];
-    if (name) byName.set(name, preds);
-  }
-  return byName;
-}
-
-/**
- * 收集源码中函数签名的 Abs inlay：
- * - 参数后：前置约束（声明 refine 优先；否则从 if 推）
- * - `)` 后：返回 shape + term（类型即计算）
- */
-export function collectAbsInlays(
-  source: string,
-  refineOpts?: { loadModule?: (spec: string, fromFile: string) => string | undefined; fromFile?: string },
-): AbsInlay[] {
-  const inlays: AbsInlay[] = [];
-  for (const { name, node } of listFunctions(source)) {
-    let g: ReturnType<typeof generalizeFromAst>;
-    try {
-      g = generalizeFromAst(name, source, refineOpts ? { refine: refineOpts } : {});
-    } catch {
-      continue;
-    }
-    if (!g) continue;
-
-    const params = g.params;
-    // 声明契约优先；if 推断作补充
-    const predsByName = new Map<string, Pred[]>();
-    if (g.entryReqs) {
-      for (const r of g.entryReqs) {
-        predsByName.set(r.param, [r.pred]);
-      }
-    }
-    for (const [k, v] of paramPreds(source, name, params)) {
-      if (!predsByName.has(k)) predsByName.set(k, v);
-    }
-
-    const fnNode = node as any;
-    const paramList: any[] = fnNode.params ?? [];
-    for (let i = 0; i < paramList.length; i++) {
-      const p = paramList[i];
-      const pname = params[i] ?? (p?.name as string | undefined);
-      if (!p?.loc || !pname) continue;
-      const preds = predsByName.get(pname);
-      if (preds && preds.length > 0) {
-        const text = preds.map(predToString).join(" ∧ ");
-        inlays.push({
-          line: p.loc.end.line,
-          character: p.loc.end.column,
-          label: `  where ${text}`,
-          kind: "parameter",
-        });
-      }
-    }
-
-    // 返回：插在函数体 `{` 前（类型即计算）
-    const bodyLoc = fnNode.body?.loc;
-    if (bodyLoc?.start) {
-      const retShape = formatShape(g.symbolic);
-      let label = `: ${retShape}`;
-      if (g.symbolic.term && g.symbolic.term.op !== "lit") {
-        label += ` = ${termToString(g.symbolic.term)}`;
-      }
-      if (g.symbolic.pred && g.symbolic.pred.op !== "true") {
-        label += `  where ${predToString(g.symbolic.pred)}`;
-      }
-      inlays.push({
-        line: bodyLoc.start.line,
-        character: Math.max(0, bodyLoc.start.column),
-        label: `${label}  `,
-        kind: "type",
-      });
-    }
-  }
-  return inlays;
-}

package/src/algebra/language.ts

@@ -1,289 +0,0 @@
-/**
- * 语言覆盖：class / new / instanceof / this / async await。
- * brand 表示名义类；eff("promise") 表示异步效应。
- *
- * 方法体：ClassDef.methods 存 AST body，调用时在 this=receiver 下求值。
- */
-
-import type { Node } from "@babel/types";
-import type { Abs } from "./abs.ts";
-import { abs, confJoin, unknown } from "./abs.ts";
-import type { AstEnv } from "./ast-eval.ts";
-
-export type MethodDef = {
-  name: string;
-  params: string[];
-  body: Node;
-  kind?: string; // "constructor" | "method" | "get" | ...
-  async?: boolean;
-};
-
-export type ClassDef = {
-  name: string;
-  instanceShape: Abs;
-  ctorParams: string[];
-  methods: Map<string, MethodDef>;
-  superClass?: string;
-};
-
-type EnvWithClasses = AstEnv & { classes?: Map<string, ClassDef> };
-
-function classesOf(env: AstEnv): Map<string, ClassDef> {
-  const e = env as EnvWithClasses;
-  if (!e.classes) e.classes = new Map();
-  return e.classes;
-}
-
-export function defineClass(env: AstEnv, def: ClassDef): void {
-  classesOf(env).set(def.name, def);
-}
-
-export function getClass(env: AstEnv, name: string): ClassDef | undefined {
-  return (env as EnvWithClasses).classes?.get(name) as ClassDef | undefined;
-}
-
-/** 沿继承链找类 */
-export function getClassChain(env: AstEnv, name: string): ClassDef[] {
-  const chain: ClassDef[] = [];
-  let cur: string | undefined = name;
-  const seen = new Set<string>();
-  while (cur && !seen.has(cur)) {
-    seen.add(cur);
-    const def = getClass(env, cur);
-    if (!def) break;
-    chain.push(def);
-    cur = def.superClass;
-  }
-  return chain;
-}
-
-/** new C(...) → brand 实例；并跑 constructor 以写入字段 */
-export function instantiateClass(
-  env: AstEnv,
-  className: string,
-  args: Abs[],
-  evalBody?: (fn: { params: string[]; body: Node }, args: Abs[], thisVal: Abs, env: AstEnv) => Abs,
-): Abs {
-  const def = getClass(env, className);
-  if (!def) {
-    return abs(
-      {
-        k: "brand",
-        name: className,
-        shape: abs({ k: "obj", slots: {} }, undefined, undefined, "exact"),
-      },
-      undefined,
-      undefined,
-      "partial",
-    );
-  }
-
-  // 先用声明 shape 建实例（含方法）
-  let instance = abs(
-    { k: "brand", name: className, shape: def.instanceShape },
-    undefined,
-    undefined,
-    "path",
-  );
-
-  // constructor：自身优先；没有则沿继承链找父类构造
-  const chain = getClassChain(env, className);
-  let ctor: MethodDef | undefined;
-  let ctorClass: ClassDef | undefined;
-  for (const cls of chain) {
-    const m = cls.methods.get("constructor");
-    if (m) {
-      ctor = m;
-      ctorClass = cls;
-      break;
-    }
-  }
-  if (ctor && evalBody) {
-    // 绑定 super → 父类（ctor 所在类的 superClass）
-    const parentName = ctorClass?.superClass;
-    const localEnv = parentName
-      ? withSuperBinding(env, className, parentName)
-      : env;
-    const fields = evalBody(ctor, args, instance, localEnv);
-    instance = mergeInstanceFields(instance, fields, className);
-  }
-
-  return instance;
-}
-
-/** 在 env 上绑定 super 类名，供 super.method() 派发 */
-function withSuperBinding(env: AstEnv, className: string, superName: string): AstEnv {
-  return { ...env, currentOwner: className };
-}
-
-/** 读取当前 this 所属类的父类名 */
-export function superNameOf(env: AstEnv, className: string): string | undefined {
-  return getClass(env, className)?.superClass;
-}
-
-/** constructor 副作用后的字段并入 brand.shape */
-function mergeInstanceFields(instance: Abs, fields: Abs, className: string): Abs {
-  if (instance.shape.k !== "brand") return instance;
-  const base = instance.shape.shape;
-  const slots: Record<string, { value: Abs }> =
-    base.shape.k === "obj" ? { ...base.shape.slots } : {};
-
-  // fields 可能是更新后的 this（brand）或裸 obj
-  const fieldObj =
-    fields.shape.k === "brand" ? fields.shape.shape : fields;
-  if (fieldObj.shape.k === "obj") {
-    for (const [k, s] of Object.entries(fieldObj.shape.slots)) {
-      slots[k] = s;
-    }
-  }
-  return abs(
-    {
-      k: "brand",
-      name: className,
-      shape: abs({ k: "obj", slots }, undefined, undefined, "exact"),
-    },
-    undefined,
-    undefined,
-    instance.conf,
-  );
-}
-
-/**
- * instanceof：沿继承链匹配 brand 名。
- */
-export function instanceOf(
-  left: Abs,
-  rightClassName: string,
-  env?: AstEnv,
-): Abs {
-  if (left.shape.k === "brand") {
-    const chainNames = env
-      ? getClassChain(env, left.shape.name).map((c) => c.name)
-      : [left.shape.name];
-    if (chainNames.includes(rightClassName) || left.shape.name === rightClassName) {
-      return { shape: { k: "prim", type: "boolean" }, term: litTrue(), conf: "exact" };
-    }
-    return { shape: { k: "prim", type: "boolean" }, term: litFalse(), conf: "exact" };
-  }
-  if (left.shape.k === "unknown") {
-    return { shape: { k: "prim", type: "boolean" }, conf: "partial" };
-  }
-  return { shape: { k: "prim", type: "boolean" }, term: litFalse(), conf: "path" };
-}
-
-function litTrue() {
-  return { op: "lit" as const, value: true };
-}
-function litFalse() {
-  return { op: "lit" as const, value: false };
-}
-
-export function projectBrand(self: Abs, key: string): Abs {
-  if (self.shape.k !== "brand") return unknown;
-  const inner = self.shape.shape;
-  if (inner.shape.k === "obj") {
-    const slot = inner.shape.slots[key];
-    if (slot) return slot.value;
-  }
-  return unknown;
-}
-
-/** 在 brand 上查找方法定义（含继承） */
-export function lookupMethod(
-  env: AstEnv,
-  receiver: Abs,
-  methodName: string,
-): MethodDef | undefined {
-  if (receiver.shape.k !== "brand") return undefined;
-  const chain = getClassChain(env, receiver.shape.name);
-  for (const cls of chain) {
-    const m = cls.methods.get(methodName);
-    if (m) return m;
-  }
-  return undefined;
-}
-
-/** 沿继承链查找方法，返回定义与所在类名 */
-export function lookupMethodWithOwner(
-  env: AstEnv,
-  receiver: Abs,
-  methodName: string,
-): { def: MethodDef; owner: string } | undefined {
-  if (receiver.shape.k !== "brand") return undefined;
-  const chain = getClassChain(env, receiver.shape.name);
-  for (const cls of chain) {
-    const m = cls.methods.get(methodName);
-    if (m) return { def: m, owner: cls.name };
-  }
-  return undefined;
-}
-
-/** super.method()：从父类开始找（跳过当前类） */
-export function lookupSuperMethod(
-  env: AstEnv,
-  receiver: Abs,
-  fromClass: string,
-  methodName: string,
-): { def: MethodDef; owner: string } | undefined {
-  if (receiver.shape.k !== "brand") return undefined;
-  const parent = superNameOf(env, fromClass) ?? getClass(env, fromClass)?.superClass;
-  if (!parent) return undefined;
-  const chain = getClassChain(env, parent);
-  for (const cls of chain) {
-    const m = cls.methods.get(methodName);
-    if (m) return { def: m, owner: cls.name };
-  }
-  return undefined;
-}
-
-export function wrapPromise(inner: Abs): Abs {
-  return abs(
-    { k: "eff", eff: "promise", inner },
-    undefined,
-    undefined,
-    confJoin(inner.conf, "path"),
-  );
-}
-
-export function awaitAbs(v: Abs): Abs {
-  if (v.shape.k === "eff" && v.shape.eff === "promise") {
-    return v.shape.inner;
-  }
-  return v;
-}
-
-export function coerceAsyncReturn(value: Abs): Abs {
-  if (value.shape.k === "eff") return value;
-  return wrapPromise(value);
-}
-
-/** 从 ClassMethod 列表构造 methods map + instance shape */
-export function classFromMethods(
-  name: string,
-  methods: MethodDef[],
-  superClass?: string,
-  superShape?: Abs,
-): ClassDef {
-  const methodMap = new Map<string, MethodDef>();
-  const slots: Record<string, { value: Abs }> = {};
-  if (superShape?.shape.k === "obj") {
-    for (const [k, s] of Object.entries(superShape.shape.slots)) {
-      slots[k] = s;
-    }
-  }
-  for (const m of methods) {
-    methodMap.set(m.name, m);
-    if (m.kind !== "constructor") {
-      slots[m.name] = {
-        value: abs({ k: "fn", params: m.params, name: m.name }, undefined, undefined, "exact"),
-      };
-    }
-  }
-  return {
-    name,
-    instanceShape: abs({ k: "obj", slots }, undefined, undefined, "exact"),
-    ctorParams: methodMap.get("constructor")?.params ?? [],
-    methods: methodMap,
-    superClass,
-  };
-}

package/src/algebra/leak.ts

@@ -1,68 +0,0 @@
-/**
- * 项（Term）防爆炸：深度/宽度阈值 → leak 为新鲜 var + 等式约束。
- */
-
-import type { Term } from "./term.ts";
-import { v, termToString, termEquals, app, lit } from "./term.ts";
-import type { Pred } from "./pred.ts";
-import { eq, and } from "./pred.ts";
-import type { Abs } from "./abs.ts";
-import { abs, confJoin } from "./abs.ts";
-
-export type LeakBudget = {
-  maxDepth: number;
-  maxNodes: number;
-};
-
-export const defaultLeakBudget: LeakBudget = {
-  maxDepth: 6,
-  maxNodes: 32,
-};
-
-export function termDepth(t: Term): number {
-  if (t.op !== "app") return 1;
-  return 1 + Math.max(0, ...t.args.map(termDepth));
-}
-
-export function termNodes(t: Term): number {
-  if (t.op !== "app") return 1;
-  return 1 + t.args.reduce((s, x) => s + termNodes(x), 0);
-}
-
-export function exceedsBudget(t: Term, budget: LeakBudget = defaultLeakBudget): boolean {
-  return termDepth(t) > budget.maxDepth || termNodes(t) > budget.maxNodes;
-}
-
-let leakCounter = 0;
-
-export function resetLeakCounter(): void {
-  leakCounter = 0;
-}
-
-/**
- * 若项超预算，替换为新鲜变量，并返回附加等式 pred：fresh = originalTerm。
- * 未超预算则原样返回。
- */
-export function maybeLeak(
-  a: Abs,
-  budget: LeakBudget = defaultLeakBudget,
-  label = "t",
-): Abs {
-  if (!a.term || a.term.op !== "app") return a;
-  if (!exceedsBudget(a.term, budget)) return a;
-
-  leakCounter += 1;
-  const id = `${label}$${leakCounter}`;
-  const fresh: Term = v(id);
-  const linkage: Pred = eq(fresh, a.term);
-  // pred：原 pred 中的 term 无法直接替换（pred 相对旧 term），改为只挂 linkage
-  // 置信度：仍 path，但标注 leaked
-  return abs(a.shape, fresh, linkage, confJoin(a.conf, "path"));
-}
-
-/**
- * 批量：在算术结果上应用 leak。
- */
-export function leakIfNeeded(a: Abs, budget?: LeakBudget, label?: string): Abs {
-  return maybeLeak(a, budget, label);
-}