@aster-cloud/aster-lang-ts 0.0.1

package/dist/src/effects/capabilities.js

@@ -0,0 +1,101 @@
+import { CapabilityKind } from '../config/semantic.js';
+export function isCapabilityKind(value) {
+    return (typeof value === 'string' &&
+        Object.values(CapabilityKind).includes(value));
+}
+export function parseLegacyCapability(cap) {
+    if (cap === 'io') {
+        return [
+            CapabilityKind.HTTP,
+            CapabilityKind.SQL,
+            CapabilityKind.TIME,
+            CapabilityKind.FILES,
+            CapabilityKind.SECRETS,
+            CapabilityKind.AI_MODEL,
+        ];
+    }
+    return [CapabilityKind.CPU];
+}
+export function normalizeManifest(raw) {
+    const normalized = { allow: {} };
+    const allow = normalized.allow;
+    if (raw?.allow) {
+        for (const key of Object.keys(raw.allow)) {
+            if (key === 'io') {
+                const patterns = raw.allow.io;
+                allow[CapabilityKind.HTTP] = patterns;
+                allow[CapabilityKind.SQL] = patterns;
+                allow[CapabilityKind.TIME] = patterns;
+                allow[CapabilityKind.FILES] = patterns;
+                allow[CapabilityKind.SECRETS] = patterns;
+                allow[CapabilityKind.AI_MODEL] = patterns;
+            }
+            else if (key === 'cpu') {
+                allow[CapabilityKind.CPU] = raw.allow.cpu;
+            }
+            else if (isCapabilityKind(key)) {
+                allow[key] = raw.allow[key];
+            }
+        }
+    }
+    if (raw?.deny) {
+        normalized.deny = {};
+        const deny = normalized.deny;
+        for (const key of Object.keys(raw.deny)) {
+            if (key === 'io') {
+                for (const cap of parseLegacyCapability('io')) {
+                    deny[cap] = raw.deny.io;
+                }
+            }
+            else if (key === 'cpu') {
+                deny[CapabilityKind.CPU] = raw.deny.cpu;
+            }
+            else if (isCapabilityKind(key)) {
+                deny[key] = raw.deny[key];
+            }
+        }
+    }
+    return normalized;
+}
+export function isAllowed(cap, funcName, ctx, man) {
+    if (!man)
+        return true; // no manifest -> permissive
+    const capsToCheck = cap === 'io' || cap === 'cpu' ? parseLegacyCapability(cap) : [cap];
+    const fqn = `${ctx.moduleName}.${funcName}`;
+    for (const c of capsToCheck) {
+        const deny = man.deny?.[c] ?? [];
+        for (const pat of deny)
+            if (matches(pat, ctx.moduleName, fqn))
+                return false;
+    }
+    let allowed = false;
+    for (const c of capsToCheck) {
+        const patterns = man.allow[c];
+        if (!patterns || patterns.length === 0)
+            continue;
+        for (const pat of patterns) {
+            if (matches(pat, ctx.moduleName, fqn)) {
+                allowed = true;
+                break;
+            }
+        }
+        if (allowed)
+            break;
+    }
+    return allowed;
+}
+function matches(pat, moduleName, fqn) {
+    if (pat === '*')
+        return true;
+    // Simple suffix wildcard: 'module.func*' → startsWith on fqn
+    if (pat.endsWith('*')) {
+        const base = pat.slice(0, -1);
+        return fqn.startsWith(base) || moduleName.startsWith(base);
+    }
+    if (pat.endsWith('.*')) {
+        const pref = pat.slice(0, -2);
+        return fqn.startsWith(pref + '.') || moduleName === pref;
+    }
+    return fqn === pat || moduleName === pat;
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/src/effects/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../../src/effects/capabilities.ts"],"names":[],"mappings":"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"}

package/dist/src/effects/effect_inference.d.ts

@@ -0,0 +1,17 @@
+import type { Core, TypecheckDiagnostic, Origin } from '../types.js';
+import type { EffectSignature } from './effect_signature.js';
+import { ModuleCache } from '../lsp/module_cache.js';
+export interface EffectConstraint {
+    caller: string;
+    callee: string;
+    location?: Origin;
+}
+export interface EffectInferenceOptions {
+    moduleName?: string;
+    moduleUri?: string | null;
+    imports?: Map<string, string>;
+    importedEffects?: Map<string, EffectSignature>;
+    moduleCache?: ModuleCache;
+}
+export declare function inferEffects(core: Core.Module, options?: EffectInferenceOptions): TypecheckDiagnostic[];
+//# sourceMappingURL=effect_inference.d.ts.map

package/dist/src/effects/effect_inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect_inference.d.ts","sourceRoot":"","sources":["../../../src/effects/effect_inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAMrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAA+B,MAAM,wBAAwB,CAAC;AAElF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA8BD,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC/C,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,mBAAmB,EAAE,CAkGvG"}

package/dist/src/effects/effect_inference.js

@@ -0,0 +1,557 @@
+import { Effect } from '../types.js';
+import { getIOPrefixes, getCPUPrefixes } from '../config/effect_config.js';
+import { DefaultCoreVisitor, createVisitorContext } from '../core/visitor.js';
+import { resolveAlias } from '../typecheck.js';
+import { cacheModuleEffectSignatures } from '../lsp/module_cache.js';
+function effectRank(atom) {
+    switch (atom) {
+        case Effect.PURE:
+            return 0;
+        case Effect.CPU:
+            return 1;
+        case Effect.IO:
+            return 2;
+        default:
+            return 3;
+    }
+}
+function strongerEffect(a, b) {
+    return effectRank(a) >= effectRank(b) ? a : b;
+}
+export function inferEffects(core, options) {
+    const ioPrefixes = getIOPrefixes();
+    const cpuPrefixes = getCPUPrefixes();
+    const funcIndex = new Map();
+    for (const decl of core.decls) {
+        if (decl.kind === 'Func')
+            funcIndex.set(decl.name, decl);
+    }
+    const constraints = [];
+    const declaredEffects = new Map();
+    const inferredEffects = new Map();
+    const requiredEffects = new Map();
+    const effectParams = new Map();
+    const bindings = new Map();
+    // 第一遍：收集局部效果和约束
+    for (const func of funcIndex.values()) {
+        const analysis = analyzeFunction(func, funcIndex, ioPrefixes, cpuPrefixes, options?.imports, options?.importedEffects);
+        constraints.push(...analysis.constraints);
+        const paramSet = new Set(func.effectParams ?? []);
+        effectParams.set(func.name, paramSet);
+        bindings.set(func.name, initBindings(paramSet));
+        const declared = new Set();
+        const declaredSource = func.declaredEffects ??
+            func.effects;
+        for (const eff of declaredSource)
+            declared.add(normalizeEffectRef(eff));
+        const inferred = new Set(declared);
+        const required = new Set();
+        for (const eff of analysis.localEffects) {
+            const ref = normalizeEffectRef(eff);
+            inferred.add(ref);
+            required.add(ref);
+        }
+        declaredEffects.set(func.name, declared);
+        inferredEffects.set(func.name, inferred);
+        requiredEffects.set(func.name, required);
+    }
+    // 第二遍：将被调函数的声明效果添加到 requiredEffects
+    for (const constraint of constraints) {
+        const callerRequired = requiredEffects.get(constraint.caller);
+        const calleeDeclared = declaredEffects.get(constraint.callee);
+        if (callerRequired && calleeDeclared) {
+            for (const eff of calleeDeclared) {
+                callerRequired.add(eff);
+            }
+        }
+    }
+    propagateEffects(constraints, inferredEffects, bindings);
+    propagateEffects(constraints, requiredEffects, bindings);
+    const resolvedDeclared = resolveEffectMap(declaredEffects, bindings);
+    const resolvedInferred = resolveEffectMap(inferredEffects, bindings);
+    const resolvedRequired = resolveEffectMap(requiredEffects, bindings);
+    const diagnostics = buildDiagnostics(funcIndex, resolvedDeclared, resolvedInferred, resolvedRequired, bindings, effectParams);
+    if (options?.moduleName) {
+        const signatures = buildEffectSignatureMap(options.moduleName, resolvedDeclared, resolvedInferred, resolvedRequired);
+        const cacheOptions = {
+            moduleName: options.moduleName,
+            uri: options.moduleUri ?? null,
+            signatures,
+            imports: options.imports ? Array.from(new Set(options.imports.values())) : [],
+        };
+        if (options.moduleCache) {
+            options.moduleCache.cacheModuleEffectSignatures(cacheOptions);
+        }
+        else {
+            cacheModuleEffectSignatures(cacheOptions);
+        }
+    }
+    return diagnostics;
+}
+function analyzeFunction(func, index, ioPrefixes, cpuPrefixes, imports, importedEffects) {
+    const constraints = [];
+    const localEffects = new Set();
+    // 使用统一的 Core 访客遍历函数体，收集调用与内建效果
+    class EffectCollector extends DefaultCoreVisitor {
+        visitStatement(statement, context) {
+            if (statement.kind === 'workflow') {
+                this.visitWorkflow(statement, context);
+                return;
+            }
+            super.visitStatement(statement, context);
+        }
+        visitWorkflow(workflow, context) {
+            // workflow 天然需要 IO 效果（调度/状态存储），即使步骤本身为纯操作也必须声明 @io
+            localEffects.add(Effect.IO);
+            for (const step of workflow.steps) {
+                this.visitBlock(step.body, context);
+                if (step.compensate)
+                    this.visitBlock(step.compensate, context);
+            }
+        }
+        visitExpression(e, context) {
+            if (e.kind === 'Call') {
+                const calleeName = extractFunctionName(e.target);
+                if (calleeName) {
+                    const resolvedName = imports ? resolveAlias(calleeName, imports) : calleeName;
+                    const isLocal = index.has(resolvedName);
+                    const imported = importedEffects?.get(resolvedName);
+                    if (imported) {
+                        for (const effect of imported.required) {
+                            localEffects.add(effect);
+                        }
+                    }
+                    else if (!isLocal) {
+                        recordBuiltinEffect(resolvedName, localEffects, ioPrefixes, cpuPrefixes);
+                    }
+                    if (isLocal) {
+                        const constraint = { caller: func.name, callee: resolvedName };
+                        const call = e;
+                        if (call.origin)
+                            constraint.location = call.origin;
+                        constraints.push(constraint);
+                    }
+                }
+            }
+            else if (e.kind === 'Lambda') {
+                // Lambda表达式：递归收集Lambda body的效应
+                const lambda = e;
+                this.visitBlock(lambda.body, context);
+                return; // Lambda body已处理，无需继续默认递归
+            }
+            // 继续默认递归
+            super.visitExpression(e, context);
+        }
+    }
+    if (func.body)
+        new EffectCollector().visitBlock(func.body, createVisitorContext());
+    return { constraints, localEffects };
+}
+function extractFunctionName(expr) {
+    return expr.kind === 'Name' ? expr.name : null;
+}
+function recordBuiltinEffect(name, effects, ioPrefixes, cpuPrefixes) {
+    if (ioPrefixes.some(prefix => name.startsWith(prefix)))
+        effects.add(Effect.IO);
+    if (cpuPrefixes.some(prefix => name.startsWith(prefix)))
+        effects.add(Effect.CPU);
+}
+function propagateEffects(constraints, effectMap, bindings) {
+    if (effectMap.size === 0)
+        return;
+    const { nodes, adjacency } = buildEffectFlowGraph(constraints, effectMap);
+    if (nodes.length === 0)
+        return;
+    seedBindingsWithEffects(effectMap, bindings);
+    const { components, componentByNode } = runTarjan(nodes, adjacency);
+    const { componentEdges, indegree } = buildComponentGraph(components, componentByNode, adjacency);
+    const order = topologicalSort(componentEdges, indegree);
+    for (const componentIndex of order) {
+        const members = components[componentIndex];
+        if (!members || members.length === 0)
+            continue;
+        const firstMember = members[0];
+        if (members.length > 1 || hasSelfLoop(firstMember, adjacency)) {
+            let localChanged = true;
+            while (localChanged) {
+                localChanged = false;
+                for (const node of members) {
+                    const neighbors = adjacency.get(node);
+                    if (!neighbors)
+                        continue;
+                    for (const neighbor of neighbors) {
+                        if (componentByNode.get(neighbor) !== componentIndex)
+                            continue;
+                        const changed = mergeEffects(node, neighbor, effectMap, bindings);
+                        if (changed)
+                            localChanged = true;
+                    }
+                }
+            }
+        }
+        for (const node of members) {
+            const neighbors = adjacency.get(node);
+            if (!neighbors)
+                continue;
+            for (const neighbor of neighbors) {
+                if (componentByNode.get(neighbor) === componentIndex)
+                    continue;
+                void mergeEffects(node, neighbor, effectMap, bindings);
+            }
+        }
+    }
+}
+function effectRefKey(ref) {
+    if (ref.kind === 'EffectVar')
+        return `var:${ref.name}`;
+    return String(ref);
+}
+function normalizeEffectRef(effect) {
+    if (effect.kind === 'EffectVar') {
+        return { kind: 'EffectVar', name: effect.name };
+    }
+    return effect;
+}
+function initBindings(params) {
+    const binding = new Map();
+    for (const name of params) {
+        binding.set(name, { value: Effect.PURE, resolved: false });
+    }
+    return binding;
+}
+function resolveEffectRef(ref, binding) {
+    if (ref.kind === 'EffectVar') {
+        const target = binding?.get(ref.name);
+        return target ? target.value : null;
+    }
+    return ref;
+}
+function addEffectAtom(target, effect) {
+    for (const existing of target) {
+        if (effectRefKey(existing) === effectRefKey(effect))
+            return false;
+    }
+    target.add(effect);
+    return true;
+}
+function updateBindingsWithEffect(funcName, effect, bindings) {
+    const binding = bindings.get(funcName);
+    if (!binding)
+        return;
+    for (const [name, entry] of binding) {
+        const merged = strongerEffect(entry.value, effect);
+        const resolved = entry.resolved || effectRank(effect) > effectRank(Effect.PURE);
+        if (merged !== entry.value || resolved !== entry.resolved) {
+            binding.set(name, { value: merged, resolved });
+        }
+    }
+}
+function seedBindingsWithEffects(effectMap, bindings) {
+    for (const [fn, effects] of effectMap) {
+        const binding = bindings.get(fn);
+        if (!binding)
+            continue;
+        for (const ref of effects) {
+            const atom = resolveEffectRef(ref, binding);
+            if (atom)
+                updateBindingsWithEffect(fn, atom, bindings);
+        }
+    }
+}
+function mergeEffects(source, target, effectMap, bindings) {
+    const sourceEffects = effectMap.get(source);
+    const targetEffects = effectMap.get(target);
+    if (!sourceEffects || !targetEffects)
+        return false;
+    const binding = bindings.get(source);
+    let changed = false;
+    for (const ref of sourceEffects) {
+        const atom = resolveEffectRef(ref, binding);
+        if (!atom)
+            continue;
+        if (addEffectAtom(targetEffects, atom)) {
+            changed = true;
+            updateBindingsWithEffect(target, atom, bindings);
+        }
+    }
+    return changed;
+}
+function resolveEffectMap(effectMap, bindings) {
+    const resolved = new Map();
+    for (const [fn, effects] of effectMap) {
+        const binding = bindings.get(fn);
+        const set = new Set();
+        for (const ref of effects) {
+            const atom = resolveEffectRef(ref, binding);
+            if (atom)
+                set.add(atom);
+        }
+        resolved.set(fn, set);
+    }
+    return resolved;
+}
+function buildEffectFlowGraph(constraints, effectMap) {
+    const adjacency = new Map();
+    const nodes = [];
+    for (const node of effectMap.keys()) {
+        nodes.push(node);
+        adjacency.set(node, new Set());
+    }
+    for (const constraint of constraints) {
+        if (!effectMap.has(constraint.caller) || !effectMap.has(constraint.callee))
+            continue;
+        let followers = adjacency.get(constraint.callee);
+        if (!followers) {
+            followers = new Set();
+            adjacency.set(constraint.callee, followers);
+        }
+        followers.add(constraint.caller);
+    }
+    return { nodes, adjacency };
+}
+function runTarjan(nodes, adjacency) {
+    let index = 0;
+    const indices = new Map();
+    const lowLinks = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const components = [];
+    const componentByNode = new Map();
+    function strongConnect(node) {
+        indices.set(node, index);
+        lowLinks.set(node, index);
+        index += 1;
+        stack.push(node);
+        onStack.add(node);
+        const neighbors = adjacency.get(node);
+        if (neighbors) {
+            for (const neighbor of neighbors) {
+                if (!indices.has(neighbor)) {
+                    strongConnect(neighbor);
+                    const currentLow = lowLinks.get(node);
+                    const neighborLow = lowLinks.get(neighbor);
+                    if (neighborLow < currentLow)
+                        lowLinks.set(node, neighborLow);
+                }
+                else if (onStack.has(neighbor)) {
+                    const currentLow = lowLinks.get(node);
+                    const neighborIndex = indices.get(neighbor);
+                    if (neighborIndex < currentLow)
+                        lowLinks.set(node, neighborIndex);
+                }
+            }
+        }
+        if (lowLinks.get(node) === indices.get(node)) {
+            const component = [];
+            while (true) {
+                const member = stack.pop();
+                if (!member)
+                    break;
+                onStack.delete(member);
+                component.push(member);
+                componentByNode.set(member, components.length);
+                if (member === node)
+                    break;
+            }
+            components.push(component);
+        }
+    }
+    for (const node of nodes) {
+        if (!indices.has(node))
+            strongConnect(node);
+    }
+    return { components, componentByNode };
+}
+function buildComponentGraph(components, componentByNode, adjacency) {
+    const componentEdges = new Map();
+    const indegree = Array.from({ length: components.length }, () => 0);
+    for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+        const componentMembers = components[componentIndex];
+        if (!componentMembers)
+            continue;
+        for (const node of componentMembers) {
+            const neighbors = adjacency.get(node);
+            if (!neighbors)
+                continue;
+            for (const neighbor of neighbors) {
+                const neighborComponent = componentByNode.get(neighbor);
+                if (neighborComponent === undefined || neighborComponent === componentIndex)
+                    continue;
+                let edges = componentEdges.get(componentIndex);
+                if (!edges) {
+                    edges = new Set();
+                    componentEdges.set(componentIndex, edges);
+                }
+                if (!edges.has(neighborComponent)) {
+                    edges.add(neighborComponent);
+                    indegree[neighborComponent] = (indegree[neighborComponent] ?? 0) + 1;
+                }
+            }
+        }
+    }
+    return { componentEdges, indegree };
+}
+function topologicalSort(componentEdges, indegree) {
+    const order = [];
+    const queue = [];
+    const visited = Array.from({ length: indegree.length }, () => false);
+    for (let i = 0; i < indegree.length; i += 1) {
+        if (indegree[i] === 0) {
+            queue.push(i);
+        }
+    }
+    while (queue.length > 0) {
+        const index = queue.shift();
+        if (visited[index])
+            continue;
+        visited[index] = true;
+        order.push(index);
+        const edges = componentEdges.get(index);
+        if (!edges)
+            continue;
+        for (const next of edges) {
+            if (next < 0 || next >= indegree.length)
+                continue;
+            const current = indegree[next];
+            if (current === undefined)
+                continue;
+            const updated = current - 1;
+            indegree[next] = updated;
+            if (updated === 0 && !visited[next]) {
+                queue.push(next);
+            }
+        }
+    }
+    if (order.length !== indegree.length) {
+        // 理论上组件图无环，此处仅保证顺序覆盖全部节点
+        for (let i = 0; i < indegree.length; i += 1) {
+            if (!visited[i])
+                order.push(i);
+        }
+    }
+    return order;
+}
+function hasSelfLoop(node, adjacency) {
+    const neighbors = adjacency.get(node);
+    return neighbors ? neighbors.has(node) : false;
+}
+function buildDiagnostics(funcIndex, declared, inferred, required, bindings, effectParams) {
+    const diagnostics = [];
+    for (const [name, func] of funcIndex) {
+        const declaredSet = declared.get(name) ?? new Set();
+        const inferredSet = inferred.get(name) ?? new Set();
+        const requiredSet = required.get(name) ?? new Set();
+        const inferredHasIO = inferredSet.has(Effect.IO);
+        const inferredHasCPU = inferredSet.has(Effect.CPU);
+        const declaredHasIO = declaredSet.has(Effect.IO);
+        const declaredHasCPU = declaredSet.has(Effect.CPU);
+        if (inferredHasIO && !declaredHasIO) {
+            const diag = {
+                severity: 'error',
+                message: `函数 '${name}' 缺少 @io 效果声明，推断要求 IO。`,
+                code: "E205" /* ErrorCode.EFF_INFER_MISSING_IO */,
+                help: '根据推断结果为函数添加 @io 效果。',
+                ...(func.span ? { span: func.span } : {}),
+                data: { func: name, effect: 'io' },
+            };
+            diagnostics.push(diag);
+        }
+        if (inferredHasCPU && !(declaredHasCPU || declaredHasIO)) {
+            const diag = {
+                severity: 'error',
+                message: `函数 '${name}' 缺少 @cpu 效果声明，推断要求 CPU（或 @io）。`,
+                code: "E206" /* ErrorCode.EFF_INFER_MISSING_CPU */,
+                help: '根据推断结果补齐 @cpu 或 @io 效果。',
+                ...(func.span ? { span: func.span } : {}),
+                data: { func: name, effect: 'cpu' },
+            };
+            diagnostics.push(diag);
+        }
+        const requiredHasIO = requiredSet.has(Effect.IO);
+        const requiredHasCPU = requiredSet.has(Effect.CPU);
+        if (declaredHasIO && !requiredHasIO) {
+            const diag = {
+                severity: 'warning',
+                message: `函数 '${name}' 声明了 @io，但推断未发现 IO 副作用。`,
+                code: "E207" /* ErrorCode.EFF_INFER_REDUNDANT_IO */,
+                help: '确认是否需要保留 @io 声明。',
+                ...(func.span ? { span: func.span } : {}),
+                data: { func: name, effect: 'io' },
+            };
+            diagnostics.push(diag);
+        }
+        if (declaredHasCPU) {
+            if (!requiredHasCPU && !requiredHasIO) {
+                const diag = {
+                    severity: 'warning',
+                    message: `函数 '${name}' 声明了 @cpu，但推断未发现 CPU 副作用。`,
+                    code: "E208" /* ErrorCode.EFF_INFER_REDUNDANT_CPU */,
+                    help: '若无 CPU 副作用，可删除 @cpu 声明。',
+                    ...(func.span ? { span: func.span } : {}),
+                    data: { func: name, effect: 'cpu' },
+                };
+                diagnostics.push(diag);
+            }
+            else if (!requiredHasCPU && requiredHasIO) {
+                const diag = {
+                    severity: 'warning',
+                    message: `函数 '${name}' 同时声明 @cpu 和 @io；由于需要 @io，@cpu 可移除。`,
+                    code: "E209" /* ErrorCode.EFF_INFER_REDUNDANT_CPU_WITH_IO */,
+                    help: '保留 @io 即可满足需求，移除多余的 @cpu。',
+                    ...(func.span ? { span: func.span } : {}),
+                    data: { func: name, effect: 'cpu' },
+                };
+                diagnostics.push(diag);
+            }
+        }
+        const binding = bindings.get(name);
+        const params = effectParams.get(name) ?? new Set();
+        if (binding && params.size > 0) {
+            const unresolved = [];
+            for (const param of params) {
+                const status = binding.get(param);
+                if (!status || !status.resolved)
+                    unresolved.push(param);
+            }
+            if (unresolved.length > 0) {
+                const diag = {
+                    severity: 'error',
+                    code: "E211" /* ErrorCode.EFFECT_VAR_UNRESOLVED */,
+                    message: `效应变量 ${unresolved.join(', ')} 无法推断出具体效果`,
+                    help: '参考调用或声明补充明确的效果（pure/cpu/io/workflow），或移除未使用的效应变量。',
+                    ...(func.span ? { span: func.span } : {}),
+                    data: { func: name, vars: unresolved },
+                };
+                diagnostics.push(diag);
+            }
+        }
+    }
+    return diagnostics;
+}
+function buildEffectSignatureMap(moduleName, declared, inferred, required) {
+    const map = new Map();
+    for (const [fn, requiredSet] of required) {
+        const qualifiedName = moduleName ? `${moduleName}.${fn}` : fn;
+        map.set(qualifiedName, {
+            module: moduleName,
+            function: fn,
+            qualifiedName,
+            declared: toEffectSet(declared.get(fn)),
+            inferred: toEffectSet(inferred.get(fn)),
+            required: toEffectSet(requiredSet),
+        });
+    }
+    return map;
+}
+function toEffectSet(source) {
+    const result = new Set();
+    if (!source)
+        return result;
+    for (const atom of source) {
+        if (atom === Effect.IO || atom === Effect.CPU || atom === Effect.PURE) {
+            result.add(atom);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=effect_inference.js.map