@hoplogic/hopjit 0.1.0

package/dist/act-body-parser.js

@@ -0,0 +1,577 @@
+// @module: act-body ^anc-struct-act-body
+// act body 解析器：``` hop_python 围栏 → ActBody AST
+// 设计见 design/spec-ast.md ^anc-ast-act-body；概念 HopSpec V3核心规范 ^anc-step-act。
+// 无推理编排：赋值 + 白名单调用 + if-else 分支（确定性条件），禁循环（for/while → 错误）。
+// Python 风格：缩进块、if cond: / elif cond: / else:、无花括号。
+import { ACT_BUILTIN_NAMES } from './act-builtins.js';
+const FENCE_OPEN = /^```hop_python\s*$/;
+const FENCE_CLOSE = /^```\s*$/;
+const LOOP_KEYWORDS = /\b(for|while)\b/;
+// ---------------------------------------------------------------------------
+// 围栏提取：从 instruction 行数组中切出 hop_python body 与剩余自然语言行
+// ---------------------------------------------------------------------------
+export function extractHopPythonFence(instructionLines) {
+    const narrative = [];
+    let bodyLines = null;
+    let bodyStartIndex = -1;
+    let inBody = false;
+    for (let i = 0; i < instructionLines.length; i++) {
+        const line = instructionLines[i];
+        const trimmed = line.trim();
+        if (!inBody && FENCE_OPEN.test(trimmed)) {
+            inBody = true;
+            bodyLines = [];
+            bodyStartIndex = i + 1;
+            continue;
+        }
+        if (inBody && FENCE_CLOSE.test(trimmed)) {
+            inBody = false;
+            continue;
+        }
+        if (inBody) {
+            bodyLines.push(line);
+        }
+        else {
+            narrative.push(line);
+        }
+    }
+    return { bodyLines, bodyStartIndex, narrative };
+}
+const KEYWORDS = new Set(['if', 'elif', 'else', 'and', 'or', 'not', 'true', 'false']);
+// 多字符运算符优先匹配
+const MULTI_OPS = ['==', '!=', '<=', '>='];
+const SINGLE_OPS = new Set(['+', '-', '*', '/', '<', '>', '=']);
+function tokenize(bodyLines, baseLine, errors) {
+    const tokens = [];
+    const indentStack = [0];
+    let ok = true;
+    for (let ln = 0; ln < bodyLines.length; ln++) {
+        const raw = bodyLines[ln];
+        const absLine = baseLine + ln;
+        // 禁循环：早拦
+        if (LOOP_KEYWORDS.test(raw)) {
+            errors.push({ kind: 'parse', line: absLine, message: 'act body 禁止循环（for/while）——循环须升 HopSpec loop 步骤' });
+            ok = false;
+        }
+        const content = raw.replace(/\s+$/, '');
+        const trimmedStart = content.replace(/^\s*/, '');
+        if (trimmedStart === '' || trimmedStart.startsWith('#'))
+            continue; // 空行/纯注释跳过
+        // 缩进只接受空格、禁 tab（hop_python 词法契约，见概念 ^anc-step-act-body-lang）。
+        // 注：act body 在 `> ` 区，`>` 紧跟的 tab 会被 RE_INSTRUCTION 吞掉，但「> 空格+tab」
+        // 形态的 tab 会残留进此处的行首空白——必须显式拦，否则缩进列数被污染却静默接受。
+        const leadingWs = content.slice(0, content.length - trimmedStart.length);
+        if (leadingWs.includes('\t')) {
+            errors.push({ kind: 'parse', line: absLine, message: 'act body 缩进只接受空格，不接受 tab' });
+            ok = false;
+        }
+        const indent = content.length - trimmedStart.length;
+        const top = indentStack[indentStack.length - 1];
+        if (indent > top) {
+            indentStack.push(indent);
+            tokens.push({ kind: 'indent', value: '', line: absLine });
+        }
+        else if (indent < top) {
+            while (indentStack.length > 1 && indent < indentStack[indentStack.length - 1]) {
+                indentStack.pop();
+                tokens.push({ kind: 'dedent', value: '', line: absLine });
+            }
+            if (indent !== indentStack[indentStack.length - 1]) {
+                errors.push({ kind: 'parse', line: absLine, message: 'act body 缩进不一致' });
+                ok = false;
+            }
+        }
+        // 行内 tokenize（剥行尾注释）
+        let s = trimmedStart;
+        const hashIdx = findCommentStart(s);
+        if (hashIdx >= 0)
+            s = s.slice(0, hashIdx).replace(/\s+$/, '');
+        let i = 0;
+        while (i < s.length) {
+            const c = s[i];
+            if (c === ' ' || c === '\t') {
+                i++;
+                continue;
+            }
+            // string
+            if (c === '"' || c === "'") {
+                const quote = c;
+                let j = i + 1;
+                let val = '';
+                while (j < s.length && s[j] !== quote) {
+                    if (s[j] === '\\' && j + 1 < s.length) {
+                        val += s[j + 1];
+                        j += 2;
+                        continue;
+                    }
+                    val += s[j];
+                    j++;
+                }
+                if (j >= s.length) {
+                    errors.push({ kind: 'parse', line: absLine, message: '未闭合字符串' });
+                    ok = false;
+                    break;
+                }
+                tokens.push({ kind: 'string', value: val, line: absLine });
+                i = j + 1;
+                continue;
+            }
+            // number
+            if (/[0-9]/.test(c) || (c === '.' && /[0-9]/.test(s[i + 1] ?? ''))) {
+                let j = i;
+                while (j < s.length && /[0-9.]/.test(s[j]))
+                    j++;
+                tokens.push({ kind: 'number', value: s.slice(i, j), line: absLine });
+                i = j;
+                continue;
+            }
+            // ident / keyword
+            if (/[A-Za-z_]/.test(c)) {
+                let j = i;
+                while (j < s.length && /[A-Za-z0-9_]/.test(s[j]))
+                    j++;
+                tokens.push({ kind: 'ident', value: s.slice(i, j), line: absLine });
+                i = j;
+                continue;
+            }
+            // multi-char op
+            const two = s.slice(i, i + 2);
+            if (MULTI_OPS.includes(two)) {
+                tokens.push({ kind: 'op', value: two, line: absLine });
+                i += 2;
+                continue;
+            }
+            // single
+            if (c === ':') {
+                tokens.push({ kind: 'colon', value: ':', line: absLine });
+                i++;
+                continue;
+            }
+            if (c === '(') {
+                tokens.push({ kind: 'lparen', value: '(', line: absLine });
+                i++;
+                continue;
+            }
+            if (c === ')') {
+                tokens.push({ kind: 'rparen', value: ')', line: absLine });
+                i++;
+                continue;
+            }
+            if (c === ',') {
+                tokens.push({ kind: 'comma', value: ',', line: absLine });
+                i++;
+                continue;
+            }
+            if (c === '.') {
+                tokens.push({ kind: 'dot', value: '.', line: absLine });
+                i++;
+                continue;
+            }
+            if (SINGLE_OPS.has(c)) {
+                tokens.push({ kind: 'op', value: c, line: absLine });
+                i++;
+                continue;
+            }
+            errors.push({ kind: 'parse', line: absLine, message: `act body 非法字符: ${c}` });
+            ok = false;
+            break;
+        }
+        tokens.push({ kind: 'newline', value: '', line: absLine });
+    }
+    // 收尾 dedent
+    while (indentStack.length > 1) {
+        indentStack.pop();
+        tokens.push({ kind: 'dedent', value: '', line: baseLine + bodyLines.length });
+    }
+    tokens.push({ kind: 'eof', value: '', line: baseLine + bodyLines.length });
+    return ok ? tokens : null;
+}
+// 找到行内注释 # 的起点（跳过字符串内的 #）
+function findCommentStart(s) {
+    let inStr = null;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (inStr) {
+            if (c === inStr)
+                inStr = null;
+            else if (c === '\\')
+                i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            inStr = c;
+            continue;
+        }
+        if (c === '#')
+            return i;
+    }
+    return -1;
+}
+// ---------------------------------------------------------------------------
+// 递归下降 parser
+// ---------------------------------------------------------------------------
+class Parser {
+    toks;
+    errors;
+    pos = 0;
+    constructor(toks, errors) {
+        this.toks = toks;
+        this.errors = errors;
+    }
+    peek() { return this.toks[this.pos]; }
+    next() { return this.toks[this.pos++]; }
+    at(kind) { return this.peek().kind === kind; }
+    atKeyword(kw) { const t = this.peek(); return t.kind === 'ident' && t.value === kw; }
+    err(msg) { this.errors.push({ kind: 'parse', line: this.peek().line, message: 'act body: ' + msg }); }
+    skipNewlines() { while (this.at('newline'))
+        this.next(); }
+    // 顶层语句块（直到 eof）
+    parseProgram() {
+        const stmts = [];
+        this.skipNewlines();
+        while (!this.at('eof')) {
+            const s = this.parseStatement();
+            if (!s)
+                break;
+            stmts.push(s);
+            this.skipNewlines();
+        }
+        return stmts;
+    }
+    // 缩进块：INDENT statement+ DEDENT
+    parseBlock() {
+        const stmts = [];
+        if (!this.at('indent')) {
+            this.err('期望缩进块');
+            return stmts;
+        }
+        this.next(); // indent
+        this.skipNewlines();
+        while (!this.at('dedent') && !this.at('eof')) {
+            const s = this.parseStatement();
+            if (!s)
+                break;
+            stmts.push(s);
+            this.skipNewlines();
+        }
+        if (this.at('dedent'))
+            this.next();
+        return stmts;
+    }
+    parseStatement() {
+        const t = this.peek();
+        if (t.kind === 'ident' && (t.value === 'if'))
+            return this.parseIf();
+        if (t.kind === 'ident' && (t.value === 'elif' || t.value === 'else')) {
+            this.err(`意外的 ${t.value}（无匹配 if）`);
+            return null;
+        }
+        // ident 开头：可能是赋值 (ident = ...) 或调用语句 (ident(...))
+        if (t.kind === 'ident' && !KEYWORDS.has(t.value)) {
+            // 向前看：下一个非该 ident 的 token
+            const save = this.pos;
+            const name = this.next().value;
+            if (this.at('op') && this.peek().value === '=') {
+                this.next(); // =
+                const value = this.parseExpr();
+                const line = t.line;
+                this.expectNewlineOrEnd();
+                return { type: 'assign', target: name, value, line };
+            }
+            // 回退，作为表达式语句（应是 call）
+            this.pos = save;
+            const expr = this.parseExpr();
+            this.expectNewlineOrEnd();
+            if (expr.type === 'call')
+                return { type: 'call', call: expr, line: t.line };
+            this.err('表达式语句只允许工具/函数调用');
+            return null;
+        }
+        this.err(`非法语句起始: ${t.value || t.kind}`);
+        this.next();
+        return null;
+    }
+    parseIf() {
+        const line = this.peek().line;
+        this.next(); // if
+        const condition = this.parseExpr();
+        this.expectColon();
+        this.expectNewline();
+        const then_body = this.parseBlock();
+        let else_body;
+        this.skipNewlines();
+        if (this.atKeyword('elif')) {
+            // elif 展开为 else_body: [嵌套 IfStmt]
+            else_body = [this.parseIf()];
+        }
+        else if (this.atKeyword('else')) {
+            this.next(); // else
+            this.expectColon();
+            this.expectNewline();
+            else_body = this.parseBlock();
+        }
+        return { type: 'if', condition, then_body, else_body, line };
+    }
+    // 表达式优先级：or > and > not > cmp > add > mul > unary > postfix > primary
+    parseExpr() { return this.parseOr(); }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.atKeyword('or')) {
+            this.next();
+            const right = this.parseAnd();
+            left = bin('or', left, right);
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseNot();
+        while (this.atKeyword('and')) {
+            this.next();
+            const right = this.parseNot();
+            left = bin('and', left, right);
+        }
+        return left;
+    }
+    parseNot() {
+        if (this.atKeyword('not')) {
+            this.next();
+            return { type: 'unary', op: 'not', operand: this.parseNot() };
+        }
+        return this.parseCmp();
+    }
+    parseCmp() {
+        let left = this.parseAdd();
+        if (this.at('op') && ['==', '!=', '<', '>', '<=', '>='].includes(this.peek().value)) {
+            const op = this.next().value;
+            const right = this.parseAdd();
+            left = bin(op, left, right);
+        }
+        return left;
+    }
+    parseAdd() {
+        let left = this.parseMul();
+        while (this.at('op') && (this.peek().value === '+' || this.peek().value === '-')) {
+            const op = this.next().value;
+            const right = this.parseMul();
+            left = bin(op, left, right);
+        }
+        return left;
+    }
+    parseMul() {
+        let left = this.parseUnary();
+        while (this.at('op') && (this.peek().value === '*' || this.peek().value === '/')) {
+            const op = this.next().value;
+            const right = this.parseUnary();
+            left = bin(op, left, right);
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.at('op') && this.peek().value === '-') {
+            this.next();
+            return { type: 'unary', op: '-', operand: this.parseUnary() };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let e = this.parsePrimary();
+        for (;;) {
+            if (this.at('dot')) {
+                this.next();
+                if (!this.at('ident')) {
+                    this.err('. 后期望字段名');
+                    break;
+                }
+                e = { type: 'field', object: e, field: this.next().value };
+            }
+            else if (this.at('lparen')) {
+                // 调用：e 必须是 var（callee 名）
+                if (e.type !== 'var') {
+                    this.err('只能调用具名函数/工具');
+                    break;
+                }
+                e = this.parseCallArgs(e.name);
+            }
+            else
+                break;
+        }
+        return e;
+    }
+    parseCallArgs(callee) {
+        this.next(); // (
+        const args = [];
+        if (!this.at('rparen')) {
+            for (;;) {
+                // 命名参数 name: expr  或  位置参数 expr
+                if (this.at('ident') && this.toks[this.pos + 1]?.kind === 'colon') {
+                    const name = this.next().value;
+                    this.next(); // ident :
+                    args.push({ name, value: this.parseExpr() });
+                }
+                else {
+                    args.push({ value: this.parseExpr() });
+                }
+                if (this.at('comma')) {
+                    this.next();
+                    continue;
+                }
+                break;
+            }
+        }
+        if (this.at('rparen'))
+            this.next();
+        else
+            this.err(') 未闭合');
+        return { type: 'call', callee, args };
+    }
+    parsePrimary() {
+        const t = this.peek();
+        if (t.kind === 'number') {
+            this.next();
+            return { type: 'literal', value: Number(t.value), literal_kind: 'number' };
+        }
+        if (t.kind === 'string') {
+            this.next();
+            return { type: 'literal', value: t.value, literal_kind: 'string' };
+        }
+        if (t.kind === 'ident' && (t.value === 'true' || t.value === 'false')) {
+            this.next();
+            return { type: 'literal', value: t.value === 'true', literal_kind: 'bool' };
+        }
+        if (t.kind === 'ident' && !KEYWORDS.has(t.value)) {
+            this.next();
+            return { type: 'var', name: t.value };
+        }
+        if (t.kind === 'lparen') {
+            this.next();
+            const e = this.parseExpr();
+            if (this.at('rparen'))
+                this.next();
+            else
+                this.err(') 未闭合');
+            return e;
+        }
+        this.err(`非法表达式起始: ${t.value || t.kind}`);
+        this.next();
+        return { type: 'literal', value: '', literal_kind: 'string' }; // 占位，错误已记
+    }
+    expectColon() { if (this.at('colon'))
+        this.next();
+    else
+        this.err('期望 :'); }
+    expectNewline() { if (this.at('newline'))
+        this.next();
+    else
+        this.err('期望换行'); }
+    expectNewlineOrEnd() { if (this.at('newline'))
+        this.next();
+    else if (!this.at('eof') && !this.at('dedent'))
+        this.err('语句后期望换行'); }
+}
+function bin(op, left, right) {
+    return { type: 'binary', op, left, right };
+}
+// ---------------------------------------------------------------------------
+// 主入口
+// ---------------------------------------------------------------------------
+export function parseActBody(bodyLines, baseLine, errors) {
+    const before = errors.length;
+    const toks = tokenize(bodyLines, baseLine, errors);
+    if (!toks)
+        return null;
+    const parser = new Parser(toks, errors);
+    const statements = parser.parseProgram();
+    if (errors.length > before)
+        return null; // 有解析错误则不产出 body
+    return { statements, source_location: { line_start: baseLine, line_end: baseLine + bodyLines.length } };
+}
+// ---------------------------------------------------------------------------
+// 序列化：ActBody AST → hop_python 文本（复用模式交付 CC 用；不要求与原文逐字符等价，
+// 语义等价即可——见 spec-ast.md serialize 是辅助工具）。@a: anc-ast-act-body
+// ---------------------------------------------------------------------------
+export function serializeActBody(body) {
+    return body.statements.map(s => serializeStmt(s, 0)).join('\n');
+}
+function indent(level) { return '    '.repeat(level); }
+function serializeStmt(stmt, level) {
+    const pad = indent(level);
+    if (stmt.type === 'assign') {
+        return `${pad}${stmt.target} = ${serializeExpr(stmt.value)}`;
+    }
+    if (stmt.type === 'call') {
+        return `${pad}${serializeExpr(stmt.call)}`;
+    }
+    // if
+    const ifs = stmt;
+    const lines = [`${pad}if ${serializeExpr(ifs.condition)}:`];
+    for (const s of ifs.then_body)
+        lines.push(serializeStmt(s, level + 1));
+    if (ifs.else_body) {
+        // elif 展开还原：else_body 恰为单个 IfStmt → 输出 elif
+        if (ifs.else_body.length === 1 && ifs.else_body[0].type === 'if') {
+            const elif = ifs.else_body[0];
+            const elifLines = serializeStmt(elif, level).split('\n');
+            elifLines[0] = `${pad}elif ${serializeExpr(elif.condition)}:`;
+            lines.push(...elifLines.slice(0));
+        }
+        else {
+            lines.push(`${pad}else:`);
+            for (const s of ifs.else_body)
+                lines.push(serializeStmt(s, level + 1));
+        }
+    }
+    return lines.join('\n');
+}
+function serializeExpr(expr) {
+    switch (expr.type) {
+        case 'literal':
+            if (expr.literal_kind === 'string')
+                return JSON.stringify(expr.value);
+            return String(expr.value);
+        case 'var': return expr.name;
+        case 'field': return `${serializeExpr(expr.object)}.${expr.field}`;
+        case 'unary': return expr.op === 'not' ? `not ${serializeExpr(expr.operand)}` : `-${serializeExpr(expr.operand)}`;
+        case 'binary': return `${serializeExpr(expr.left)} ${expr.op} ${serializeExpr(expr.right)}`;
+        case 'call': {
+            const c = expr;
+            const args = c.args.map(a => a.name ? `${a.name}: ${serializeExpr(a.value)}` : serializeExpr(a.value)).join(', ');
+            return `${c.callee}(${args})`;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 判定 body 是否含工具调用（callee 不在内置白名单 = 工具调用，需 caller 执行）。
+// CLI next 据此分流：无工具 body 引擎消化，含工具 body 交 caller。
+// 见 design/hop-cli.md ^anc-cli-next-drives-body。@a: anc-cli-next-drives-body
+// ---------------------------------------------------------------------------
+export function bodyHasToolCall(body) {
+    return body.statements.some(stmtHasToolCall);
+}
+function stmtHasToolCall(stmt) {
+    if (stmt.type === 'assign')
+        return exprHasToolCall(stmt.value);
+    if (stmt.type === 'call')
+        return exprHasToolCall(stmt.call);
+    // if
+    if (exprHasToolCall(stmt.condition))
+        return true;
+    if (stmt.then_body.some(stmtHasToolCall))
+        return true;
+    if (stmt.else_body && stmt.else_body.some(stmtHasToolCall))
+        return true;
+    return false;
+}
+function exprHasToolCall(expr) {
+    switch (expr.type) {
+        case 'literal':
+        case 'var': return false;
+        case 'field': return exprHasToolCall(expr.object);
+        case 'unary': return exprHasToolCall(expr.operand);
+        case 'binary': return exprHasToolCall(expr.left) || exprHasToolCall(expr.right);
+        case 'call':
+            // callee 不在内置白名单 = 工具调用
+            if (!ACT_BUILTIN_NAMES.has(expr.callee))
+                return true;
+            return expr.args.some(a => exprHasToolCall(a.value));
+    }
+}

package/dist/act-builtins.d.ts

@@ -0,0 +1,12 @@
+export interface BuiltinFn {
+    name: string;
+    arity: {
+        min: number;
+        max: number;
+    };
+    fn: (args: unknown[]) => unknown;
+}
+/** hop_python 内置函数白名单：函数名 → 实现（含 arity），parser 校验 B2 与 interpreter 执行共用。见 [[act-body#^anc-exec-act-body-interp]] */
+export declare const ACT_BUILTINS: ReadonlyMap<string, BuiltinFn>;
+/** 内置函数名集合，供 validator/parser 快速查白名单成员。见 [[act-body#^anc-exec-act-body-interp]] */
+export declare const ACT_BUILTIN_NAMES: ReadonlySet<string>;

package/dist/act-builtins.js

@@ -0,0 +1,104 @@
+// @module: act-body ^anc-struct-act-body
+// act body 内置函数白名单：纯函数、无副作用、确定性。
+// 设计见 design/spec-parser.md ^anc-rule-b2；概念 ^anc-step-act-body-lang「能力边界=白名单」。
+// 刻意排除 IO/随机/时间/网络——这些走 ToolProvider 工具（受沙箱约束）。
+// @a: anc-rule-b2
+function num(v) {
+    const n = typeof v === 'number' ? v : Number(v);
+    if (Number.isNaN(n))
+        throw new Error(`期望数字，实际: ${JSON.stringify(v)}`);
+    return n;
+}
+function str(v) {
+    return typeof v === 'string' ? v : String(v);
+}
+function arr(v) {
+    if (Array.isArray(v))
+        return v;
+    throw new Error(`期望数组，实际: ${JSON.stringify(v)}`);
+}
+const BUILTINS = [
+    // 数值
+    { name: 'len', arity: { min: 1, max: 1 }, fn: (a) => {
+            const v = a[0];
+            if (Array.isArray(v))
+                return v.length;
+            if (typeof v === 'string')
+                return v.length;
+            if (v && typeof v === 'object')
+                return Object.keys(v).length;
+            throw new Error('len 期望数组/字符串/对象');
+        } },
+    { name: 'min', arity: { min: 1, max: Infinity }, fn: (a) => Math.min(...a.map(num)) },
+    { name: 'max', arity: { min: 1, max: Infinity }, fn: (a) => Math.max(...a.map(num)) },
+    { name: 'round', arity: { min: 1, max: 2 }, fn: (a) => {
+            const n = num(a[0]);
+            const d = a.length > 1 ? num(a[1]) : 0;
+            const f = Math.pow(10, d);
+            return Math.round(n * f) / f;
+        } },
+    { name: 'abs', arity: { min: 1, max: 1 }, fn: (a) => Math.abs(num(a[0])) },
+    { name: 'sum', arity: { min: 1, max: 1 }, fn: (a) => arr(a[0]).reduce((s, x) => s + num(x), 0) },
+    // 字符串
+    { name: 'lower', arity: { min: 1, max: 1 }, fn: (a) => str(a[0]).toLowerCase() },
+    { name: 'upper', arity: { min: 1, max: 1 }, fn: (a) => str(a[0]).toUpperCase() },
+    { name: 'trim', arity: { min: 1, max: 1 }, fn: (a) => str(a[0]).trim() },
+    { name: 'split', arity: { min: 2, max: 2 }, fn: (a) => str(a[0]).split(str(a[1])) },
+    { name: 'join', arity: { min: 2, max: 2 }, fn: (a) => arr(a[0]).map(str).join(str(a[1])) },
+    { name: 'replace', arity: { min: 3, max: 3 }, fn: (a) => str(a[0]).split(str(a[1])).join(str(a[2])) },
+    { name: 'contains', arity: { min: 2, max: 2 }, fn: (a) => {
+            const hay = a[0];
+            if (Array.isArray(hay))
+                return hay.includes(a[1]);
+            return str(hay).includes(str(a[1]));
+        } },
+    // 结构
+    { name: 'count', arity: { min: 1, max: 1 }, fn: (a) => arr(a[0]).length },
+    { name: 'keys', arity: { min: 1, max: 1 }, fn: (a) => {
+            const v = a[0];
+            if (v && typeof v === 'object' && !Array.isArray(v))
+                return Object.keys(v);
+            throw new Error('keys 期望对象');
+        } },
+    { name: 'values', arity: { min: 1, max: 1 }, fn: (a) => {
+            const v = a[0];
+            if (v && typeof v === 'object' && !Array.isArray(v))
+                return Object.values(v);
+            throw new Error('values 期望对象');
+        } },
+    { name: 'get', arity: { min: 2, max: 3 }, fn: (a) => {
+            const obj = a[0];
+            const key = str(a[1]);
+            const def = a.length > 2 ? a[2] : null;
+            if (obj && typeof obj === 'object' && key in obj)
+                return obj[key];
+            return def;
+        } },
+    // 类型转换
+    { name: 'to_number', arity: { min: 1, max: 1 }, fn: (a) => num(a[0]) },
+    { name: 'to_string', arity: { min: 1, max: 1 }, fn: (a) => str(a[0]) },
+    { name: 'to_bool', arity: { min: 1, max: 1 }, fn: (a) => {
+            const v = a[0];
+            if (typeof v === 'boolean')
+                return v;
+            if (typeof v === 'string')
+                return /^(true|yes|1)$/i.test(v.trim());
+            return Boolean(v);
+        } },
+    // 判定
+    { name: 'is_null', arity: { min: 1, max: 1 }, fn: (a) => a[0] === null || a[0] === undefined },
+    { name: 'is_empty', arity: { min: 1, max: 1 }, fn: (a) => {
+            const v = a[0];
+            if (v === null || v === undefined)
+                return true;
+            if (Array.isArray(v) || typeof v === 'string')
+                return v.length === 0;
+            if (typeof v === 'object')
+                return Object.keys(v).length === 0;
+            return false;
+        } },
+];
+/** hop_python 内置函数白名单：函数名 → 实现（含 arity），parser 校验 B2 与 interpreter 执行共用。见 [[act-body#^anc-exec-act-body-interp]] */
+export const ACT_BUILTINS = new Map(BUILTINS.map(b => [b.name, b]));
+/** 内置函数名集合，供 validator/parser 快速查白名单成员。见 [[act-body#^anc-exec-act-body-interp]] */
+export const ACT_BUILTIN_NAMES = new Set(BUILTINS.map(b => b.name));