gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/move/move-ingest.js

@@ -0,0 +1,320 @@
+/**
+ * Phase: moveIngest
+ *
+ * Compiler-first Move ingestion via the move-flow MCP server. **No raw Move
+ * source is ever read.** The `facts` query is the ONLY ingestion path: if the
+ * move-flow build doesn't expose it, the phase fails fast with a clear upgrade
+ * error before touching any package. Call edges come from the `call_graph`
+ * query.
+ *
+ * Note: move-flow's `facts` query elides all `#[test]` and `#[test_only]`
+ * symbols (functions, structs, constants). The graph therefore contains only
+ * production symbols; queries to find test functions or exclude tests from
+ * impact do not need a symbol-level test filter.
+ *
+ * @deps    structure
+ * @reads   scannedFiles (from structure phase)
+ * @writes  graph (Module/Function/Struct/Enum/EnumVariant/Const nodes +
+ *          CALLS/DEFINES/CONTAINS/FRIEND_OF/READS_RESOURCE/WRITES_RESOURCE/
+ *          ACQUIRES/USES_TYPE/ENTRY_POINT_OF/IMPORTS edges)
+ */
+import * as path from 'node:path';
+import { getPhaseOutput } from '../ingestion/pipeline-phases/types.js';
+import { MOVE_EDGE_REASON, moveRepoRelativePath } from './constants.js';
+import { MoveFlowToolCallError, } from './mcp-client.js';
+import { buildLocalNameIndex, mapFactsToGraph, resolveFriendEdges, resolveLambdaHostEdges, resolveResourceEdges, resolveTypeRefEdges, } from './facts-mapper.js';
+import { moveModuleNodeId, moveModuleQualifiedName, moveRelId } from './symbol-id.js';
+import { emptyFactsIssue, validateMoveIngestOutput, } from './consistency.js';
+import { createMoveEntryPointEdges } from './entry-points.js';
+function createState() {
+    return {
+        ingestedFiles: new Set(),
+        moduleFileMap: new Map(),
+        functionNodeMap: new Map(),
+        structNodeMap: new Map(),
+        modulePackageMap: new Map(),
+        filePackageMap: new Map(),
+        callGraphByPackage: new Map(),
+        pendingResource: [],
+        pendingFriends: [],
+        pendingTypeRef: [],
+        pendingLambdaHosts: [],
+        droppedResourceRefs: [],
+    };
+}
+function toOutput(state, packageRoots, consistencyIssues = []) {
+    return {
+        ingestedFiles: state.ingestedFiles,
+        packageRoots,
+        moduleFileMap: state.moduleFileMap,
+        functionNodeMap: state.functionNodeMap,
+        structNodeMap: state.structNodeMap,
+        modulePackageMap: state.modulePackageMap,
+        filePackageMap: state.filePackageMap,
+        callGraphByPackage: state.callGraphByPackage,
+        droppedResourceRefs: state.droppedResourceRefs,
+        consistencyIssues,
+    };
+}
+/** Add a mapped package's nodes/edges to the graph and merge its identity maps. */
+function applyMapped(graph, mapped, pkgRoot, state) {
+    for (const node of mapped.nodes)
+        graph.addNode(node);
+    for (const rel of mapped.edges)
+        graph.addRelationship(rel);
+    for (const [qn, file] of mapped.moduleFileMap) {
+        state.moduleFileMap.set(qn, file);
+        state.modulePackageMap.set(qn, pkgRoot);
+        state.filePackageMap.set(file, pkgRoot);
+    }
+    for (const [qn, id] of mapped.functionNodeMap)
+        state.functionNodeMap.set(qn, id);
+    for (const [qn, id] of mapped.structNodeMap)
+        state.structNodeMap.set(qn, id);
+    state.pendingResource.push(...mapped.pendingResource);
+    state.pendingFriends.push(...mapped.pendingFriends);
+    state.pendingTypeRef.push(...mapped.pendingTypeRef);
+    state.pendingLambdaHosts.push(...mapped.pendingLambdaHosts);
+}
+export function createMoveIngestPhase(client) {
+    return {
+        name: 'standaloneIngest',
+        deps: ['structure'],
+        async execute(ctx, deps) {
+            const { scannedFiles, totalFiles } = getPhaseOutput(deps, 'structure');
+            const packageRoots = [
+                ...new Set(scannedFiles
+                    .map((f) => f.path)
+                    .filter((p) => p.endsWith('Move.toml'))
+                    .map((p) => path.dirname(path.resolve(ctx.repoPath, p)))),
+            ].sort();
+            if (!client || packageRoots.length === 0) {
+                return toOutput(createState(), packageRoots);
+            }
+            const { hasFactsQuery, hasStatusTool } = await client.capabilities();
+            if (!hasFactsQuery) {
+                // userActionable: rendered as a one-liner without a stack — the fix is
+                // an operator action (upgrade move-flow), not a code bug.
+                throw Object.assign(new Error('move-flow is too old — upgrade to a build that exposes `move_package_query { query: "facts" }`.'), { userActionable: true });
+            }
+            const state = createState();
+            // Group scanned .move files by their (innermost) owning package. Files
+            // are marked as ingested per package only AFTER its facts arrive, so a
+            // package whose facts come back empty is left un-ingested rather than
+            // silently absent from the graph (the generic parse phase still sees it).
+            const moveFilesByPackage = new Map();
+            for (const f of scannedFiles) {
+                if (!f.path.endsWith('.move'))
+                    continue;
+                const abs = path.resolve(ctx.repoPath, f.path);
+                // Boundary-safe: bare startsWith would let a sibling directory sharing
+                // a name prefix (pkg_ab vs root pkg_a) claim the file.
+                const owners = packageRoots.filter((root) => {
+                    const prefix = root.endsWith(path.sep) ? root : root + path.sep;
+                    return abs.startsWith(prefix);
+                });
+                if (owners.length === 0)
+                    continue;
+                const owner = owners.reduce((a, b) => (b.length > a.length ? b : a));
+                const files = moveFilesByPackage.get(owner) ?? [];
+                files.push(moveRepoRelativePath(abs, ctx.repoPath));
+                moveFilesByPackage.set(owner, files);
+            }
+            const emptyFactsPackages = [];
+            // Pass 1: per-package nodes/edges (all packages first, so cross-package
+            // CALLS in Pass 2 can resolve callees in later packages).
+            for (const pkgRoot of packageRoots) {
+                ctx.onProgress({
+                    phase: 'moveIngest',
+                    percent: 18,
+                    message: `Ingesting Move package: ${path.basename(pkgRoot)}`,
+                    stats: { filesProcessed: 0, totalFiles, nodesCreated: ctx.graph.nodeCount },
+                });
+                let callGraphData;
+                let factsMap;
+                try {
+                    callGraphData = await client.callGraph(pkgRoot);
+                    factsMap = await client.facts(pkgRoot);
+                }
+                catch (err) {
+                    if (err instanceof MoveFlowToolCallError) {
+                        // userActionable: rendered as a one-liner without a stack - a Move
+                        // package that does not build (bad manifest, missing dependency,
+                        // nonexistent path) is an operator problem, not a code bug.
+                        throw Object.assign(new Error(`move-flow could not build Move package ${pkgRoot}: ${err.message}`), { userActionable: true });
+                    }
+                    throw err;
+                }
+                const pkgMoveFiles = moveFilesByPackage.get(pkgRoot) ?? [];
+                if (Object.keys(factsMap).length === 0 && pkgMoveFiles.length > 0) {
+                    // Facts `{}` is ambiguous: syntax-broken packages return it as a
+                    // SUCCESS (the compiler diagnostic only surfaces via
+                    // `move_package_status`), but so do valid packages whose every item
+                    // is `#[test]`/`#[test_only]` (elided from facts - see file header).
+                    // Cross-check the build status to tell them apart; either way skip
+                    // the package (its files stay un-ingested) and record an issue.
+                    emptyFactsPackages.push({
+                        pkgRoot,
+                        moveFileCount: pkgMoveFiles.length,
+                        status: await probePackageStatus(client, pkgRoot, hasStatusTool),
+                    });
+                    continue;
+                }
+                // Only past the gate: a skipped package must have zero footprint in
+                // Pass 2 linking and consistency validation.
+                state.callGraphByPackage.set(pkgRoot, callGraphData);
+                for (const rel of pkgMoveFiles)
+                    state.ingestedFiles.add(rel);
+                applyMapped(ctx.graph, mapFactsToGraph(factsMap, pkgRoot, ctx.repoPath), pkgRoot, state);
+            }
+            // Pass 2+: link edges that need the full cross-package node index.
+            linkCallEdges(ctx.graph, state);
+            linkLambdaHostEdges(ctx.graph, state);
+            linkResourceAndFriendEdges(ctx.graph, state);
+            linkFileImports(ctx.graph, state);
+            linkFileModuleContains(ctx.graph, state);
+            const output = toOutput(state, packageRoots);
+            createMoveEntryPointEdges(ctx.graph, output);
+            const consistencyIssues = emptyFactsPackages.map(emptyFactsIssue);
+            consistencyIssues.push(...validateMoveIngestOutput(ctx.graph, output));
+            reportConsistencyIssues(ctx, consistencyIssues);
+            return { ...output, consistencyIssues };
+        },
+    };
+}
+// --- Empty-facts discrimination ---
+/** Cross-check the build status of a sources-but-empty-facts package.
+ *  `null` = status unavailable (no status tool, or the probe itself failed). */
+async function probePackageStatus(client, pkgRoot, hasStatusTool) {
+    if (!hasStatusTool)
+        return null;
+    try {
+        return await client.packageStatus(pkgRoot);
+    }
+    catch {
+        // Probe failure -> cannot discriminate; fall back to the pessimistic issue.
+        return null;
+    }
+}
+/** CALLS edges from each package's call graph (resolved across all packages). */
+function linkCallEdges(graph, state) {
+    for (const callGraph of state.callGraphByPackage.values()) {
+        for (const [callerQualified, callees] of Object.entries(callGraph)) {
+            const callerId = state.functionNodeMap.get(callerQualified);
+            if (!callerId)
+                continue;
+            for (const calleeQualified of callees) {
+                const calleeId = state.functionNodeMap.get(calleeQualified);
+                if (!calleeId)
+                    continue;
+                graph.addRelationship({
+                    id: moveRelId(callerId, 'CALLS', calleeId, MOVE_EDGE_REASON.calls),
+                    sourceId: callerId,
+                    targetId: calleeId,
+                    type: 'CALLS',
+                    confidence: 1.0,
+                    reason: MOVE_EDGE_REASON.calls,
+                });
+            }
+        }
+    }
+}
+/**
+ * CALLS edges from each `__lambda__N__host` function back to its host. move-flow
+ * synthesises lambdas as standalone functions but does NOT include the host-to-
+ * lambda link in `call_graph` — without it, upstream traversal from the lambda
+ * dead-ends and processes that route through a callback (e.g. market_callbacks
+ * → settle_trade) lose the bridge.
+ */
+function linkLambdaHostEdges(graph, state) {
+    resolveLambdaHostEdges(state.pendingLambdaHosts, state.functionNodeMap, (rel) => graph.addRelationship(rel));
+}
+/** Resource/friend edges from facts, resolved after all package nodes exist. */
+function linkResourceAndFriendEdges(graph, state) {
+    const structIdsByLocalName = buildLocalNameIndex(state.structNodeMap);
+    resolveResourceEdges(state.pendingResource, state.structNodeMap, structIdsByLocalName, (rel) => graph.addRelationship(rel), (pending) => state.droppedResourceRefs.push({ fnNodeId: pending.fnNodeId, target: pending.target }), (pending) => state.droppedResourceRefs.push({ fnNodeId: pending.fnNodeId, target: pending.target }));
+    resolveFriendEdges(state.pendingFriends, state.moduleFileMap, (rel) => graph.addRelationship(rel));
+    resolveTypeRefEdges(state.pendingTypeRef, state.structNodeMap, structIdsByLocalName, (rel) => {
+        graph.addRelationship(rel);
+        addUsedType(graph, rel.sourceId, rel.targetId);
+    });
+}
+function addUsedType(graph, functionNodeId, typeNodeId) {
+    const fnNode = graph.getNode(functionNodeId);
+    const typeNode = graph.getNode(typeNodeId);
+    const qualifiedName = typeNode?.properties.qualifiedName;
+    // Only Function nodes carry `usedTypes` - resource-group membership USES_TYPE
+    // edges have a Struct source and must not grow the property there.
+    if (!fnNode || fnNode.label !== 'Function' || typeof qualifiedName !== 'string')
+        return;
+    const current = Array.isArray(fnNode.properties.usedTypes) ? fnNode.properties.usedTypes : [];
+    if (current.includes(qualifiedName))
+        return;
+    fnNode.properties.usedTypes = [...current, qualifiedName];
+}
+/** File→File IMPORTS derived from cross-module CALLS (deduped against existing). */
+function linkFileImports(graph, state) {
+    const seen = new Set();
+    for (const r of graph.iterRelationshipsByType('IMPORTS')) {
+        if (!r.sourceId.startsWith('File:') || !r.targetId.startsWith('File:'))
+            continue;
+        seen.add(`${r.sourceId.slice(5)}\0${r.targetId.slice(5)}`);
+    }
+    for (const callGraph of state.callGraphByPackage.values()) {
+        for (const [callerQualified, callees] of Object.entries(callGraph)) {
+            const callerFile = state.moduleFileMap.get(moveModuleQualifiedName(callerQualified));
+            if (!callerFile)
+                continue;
+            for (const calleeQualified of callees) {
+                const calleeFile = state.moduleFileMap.get(moveModuleQualifiedName(calleeQualified));
+                if (!calleeFile || calleeFile === callerFile)
+                    continue;
+                const key = `${callerFile}\0${calleeFile}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const sourceFileId = `File:${callerFile}`;
+                const targetFileId = `File:${calleeFile}`;
+                if (graph.getNode(sourceFileId) && graph.getNode(targetFileId)) {
+                    graph.addRelationship({
+                        id: moveRelId(sourceFileId, 'IMPORTS', targetFileId, MOVE_EDGE_REASON.crossModuleDependency),
+                        sourceId: sourceFileId,
+                        targetId: targetFileId,
+                        type: 'IMPORTS',
+                        confidence: 0.9,
+                        reason: MOVE_EDGE_REASON.crossModuleDependency,
+                    });
+                }
+            }
+        }
+    }
+}
+/** File→Module CONTAINS where the File node exists (from the structure phase). */
+function linkFileModuleContains(graph, state) {
+    for (const [qn, file] of state.moduleFileMap) {
+        const fileNodeId = `File:${file}`;
+        const moduleNodeId = moveModuleNodeId(qn, file);
+        if (graph.getNode(fileNodeId) && graph.getNode(moduleNodeId)) {
+            graph.addRelationship({
+                id: moveRelId(fileNodeId, 'CONTAINS', moduleNodeId, MOVE_EDGE_REASON.moduleInFile),
+                sourceId: fileNodeId,
+                targetId: moduleNodeId,
+                type: 'CONTAINS',
+                confidence: 1.0,
+                reason: MOVE_EDGE_REASON.moduleInFile,
+            });
+        }
+    }
+}
+/** Surface consistency errors so they reach a human/log (not just the output). */
+function reportConsistencyIssues(ctx, issues) {
+    const errors = issues.filter((i) => i.severity === 'error');
+    if (errors.length === 0)
+        return;
+    ctx.onProgress({
+        phase: 'moveIngest',
+        percent: 22,
+        message: `Move ingest: ${errors.length} consistency error(s) (e.g. ${errors[0].message})`,
+        stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: ctx.graph.nodeCount },
+    });
+}

package/dist/core/move/provision.d.ts

@@ -0,0 +1,19 @@
+import type { MoveCompilerIdentity } from './constants.js';
+import { type MoveFlowMcpClient, type ResolvedMoveFlowClient } from './mcp-client.js';
+import { type MoveFlowInstallResult, type VerifiedMoveFlowBinary } from './install.js';
+export interface ProvisionedMoveFlow {
+    client: MoveFlowMcpClient;
+    identity: MoveCompilerIdentity;
+}
+export interface MoveFlowProvisionOptions {
+    onLog?: (message: string) => void;
+    install?: boolean;
+}
+export interface MoveFlowProvisionDependencies {
+    resolveClient: (binaryPath?: string) => ResolvedMoveFlowClient | null;
+    createClient: (binaryPath: string) => MoveFlowMcpClient;
+    findCached: () => Promise<VerifiedMoveFlowBinary | null>;
+    install: () => Promise<MoveFlowInstallResult>;
+}
+/** Resolve move-flow after the caller has already detected Move code. */
+export declare function ensureMoveFlowRuntime(options?: MoveFlowProvisionOptions, dependencies?: MoveFlowProvisionDependencies): Promise<ProvisionedMoveFlow | null>;

package/dist/core/move/provision.js

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { createMoveFlowClient, tryResolveMoveFlowClient, } from './mcp-client.js';
+import { findCachedMoveFlowBinary, installMoveFlow, } from './install.js';
+import { isCompatibleMoveFlowVersion, MOVE_FLOW_RELEASE } from './release.js';
+const installAttempts = new WeakMap();
+const defaultDependencies = {
+    resolveClient: tryResolveMoveFlowClient,
+    createClient: createMoveFlowClient,
+    findCached: findCachedMoveFlowBinary,
+    install: installMoveFlow,
+};
+const localIdentity = (source, locator, version) => ({
+    version,
+    source,
+    fingerprint: createHash('sha256').update(`${source}\0${locator}\0${version}`).digest('hex'),
+});
+const verifiedRuntime = (binary, dependencies) => isCompatibleMoveFlowVersion(binary.version)
+    ? {
+        client: dependencies.createClient(binary.binaryPath),
+        identity: {
+            version: binary.version,
+            source: 'release',
+            fingerprint: binary.fingerprint,
+        },
+    }
+    : null;
+const getInstallAttempt = (dependencies) => {
+    const active = installAttempts.get(dependencies);
+    if (active)
+        return active;
+    const created = Promise.resolve().then(dependencies.install);
+    installAttempts.set(dependencies, created);
+    void created.then((result) => {
+        if (result.binary && installAttempts.get(dependencies) === created) {
+            installAttempts.delete(dependencies);
+        }
+    }, () => { });
+    return created;
+};
+/** Resolve move-flow after the caller has already detected Move code. */
+export async function ensureMoveFlowRuntime(options = {}, dependencies = defaultDependencies) {
+    const explicitPath = process.env.MOVE_FLOW;
+    if (explicitPath) {
+        const resolved = dependencies.resolveClient(explicitPath);
+        if (resolved) {
+            return {
+                client: resolved.client,
+                identity: localIdentity('explicit', explicitPath, resolved.version),
+            };
+        }
+        options.onLog?.(`MOVE_FLOW points to an unavailable binary (${explicitPath}); automatic installation was skipped.`);
+        return null;
+    }
+    const cached = await dependencies.findCached();
+    if (cached) {
+        const runtime = verifiedRuntime(cached, dependencies);
+        if (runtime)
+            return runtime;
+    }
+    const existing = dependencies.resolveClient();
+    if (existing) {
+        // The locator must be stable across shells: $PATH itself differs between
+        // terminals/CI steps, and a fingerprint churn forces a full re-index.
+        return {
+            client: existing.client,
+            identity: localIdentity('path', 'move-flow', existing.version),
+        };
+    }
+    if (options.install === false)
+        return null;
+    options.onLog?.(`Move code detected; ensuring move-flow ${MOVE_FLOW_RELEASE.version} is available.`);
+    let result;
+    try {
+        result = await getInstallAttempt(dependencies);
+    }
+    catch (err) {
+        options.onLog?.(`move-flow installation failed: ${err instanceof Error ? err.message : String(err)}; ` +
+            '.move files will not be indexed.');
+        return null;
+    }
+    if (!result.binary) {
+        options.onLog?.(`move-flow is unavailable${result.message ? `: ${result.message}` : ''}; ` +
+            '.move files will not be indexed.');
+        return null;
+    }
+    const runtime = verifiedRuntime(result.binary, dependencies);
+    if (!runtime) {
+        options.onLog?.(`move-flow ${result.binary.version} is protocol-incompatible; .move files will not be indexed.`);
+    }
+    return runtime;
+}

package/dist/core/move/release.d.ts

@@ -0,0 +1,6 @@
+export declare const MOVE_FLOW_RELEASE: {
+    readonly version: "2.0.0";
+    readonly repository: "aptos-labs/aptos-ai";
+    readonly tagPrefix: "move-flow-v";
+};
+export declare const isCompatibleMoveFlowVersion: (version: string) => boolean;

package/dist/core/move/release.js

@@ -0,0 +1,10 @@
+export const MOVE_FLOW_RELEASE = {
+    version: '2.0.0',
+    repository: 'aptos-labs/aptos-ai',
+    tagPrefix: 'move-flow-v',
+};
+const COMPATIBLE_MAJOR = Number(MOVE_FLOW_RELEASE.version.split('.')[0]);
+export const isCompatibleMoveFlowVersion = (version) => {
+    const match = /^(\d+)\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.exec(version);
+    return match !== null && Number(match[1]) === COMPATIBLE_MAJOR;
+};

package/dist/core/move/symbol-id.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Canonical Move symbol identity helpers.
+ *
+ * Move symbols need the fully-qualified address/module path in their graph IDs.
+ * File path + local name is not unique when a file contains multiple modules or
+ * two named-address packages expose the same local names.
+ */
+export interface ParsedMoveModuleName {
+    address: string;
+    moduleName: string;
+}
+export declare function parseMoveModuleQualifiedName(qualifiedName: string): ParsedMoveModuleName;
+export declare function moveModuleQualifiedName(symbolQualifiedName: string): string;
+export declare function moveLocalName(qualifiedName: string): string;
+export declare function moveShortSymbol(qualifiedName: string): string;
+/**
+ * Deterministic relationship id: re-analysis is reproducible and edges dedup
+ * by id. `reason` is part of the key so edges differing only by reason
+ * (e.g. USES_TYPE param vs return) stay distinct.
+ */
+export declare function moveRelId(sourceId: string, type: string, targetId: string, reason: string): string;
+export declare function moveModuleNodeId(moduleQualifiedName: string, filePath: string): string;
+export declare function moveFunctionNodeId(functionQualifiedName: string, filePath: string): string;
+export declare function moveStructNodeId(structQualifiedName: string, filePath: string): string;
+export declare function moveEnumNodeId(enumQualifiedName: string, filePath: string): string;
+export declare function moveConstNodeId(constQualifiedName: string, filePath: string): string;
+export declare function moveEnumVariantNodeId(enumQualifiedName: string, variantName: string, filePath: string): string;
+export declare function moveFieldNodeId(structQualifiedName: string, fieldName: string, filePath: string): string;
+/**
+ * Parse `__lambda__<n>__<host>` into the host function's local name, or null
+ * when the input is not a lambda symbol. move-flow synthesises lambdas as
+ * Function symbols whose names follow this convention so they can be referenced
+ * by the call graph; the host is always in the same module as the lambda.
+ */
+export declare function parseMoveLambdaHostName(localName: string): string | null;

package/dist/core/move/symbol-id.js

@@ -0,0 +1,65 @@
+/**
+ * Canonical Move symbol identity helpers.
+ *
+ * Move symbols need the fully-qualified address/module path in their graph IDs.
+ * File path + local name is not unique when a file contains multiple modules or
+ * two named-address packages expose the same local names.
+ */
+export function parseMoveModuleQualifiedName(qualifiedName) {
+    const sep = qualifiedName.indexOf('::');
+    if (sep === -1)
+        return { address: '', moduleName: qualifiedName };
+    return { address: qualifiedName.slice(0, sep), moduleName: qualifiedName.slice(sep + 2) };
+}
+export function moveModuleQualifiedName(symbolQualifiedName) {
+    const sep = symbolQualifiedName.lastIndexOf('::');
+    return sep === -1 ? symbolQualifiedName : symbolQualifiedName.slice(0, sep);
+}
+export function moveLocalName(qualifiedName) {
+    const sep = qualifiedName.lastIndexOf('::');
+    return sep === -1 ? qualifiedName : qualifiedName.slice(sep + 2);
+}
+export function moveShortSymbol(qualifiedName) {
+    const moduleQualified = moveModuleQualifiedName(qualifiedName);
+    const { moduleName } = parseMoveModuleQualifiedName(moduleQualified);
+    return `${moduleName}::${moveLocalName(qualifiedName)}`;
+}
+/**
+ * Deterministic relationship id: re-analysis is reproducible and edges dedup
+ * by id. `reason` is part of the key so edges differing only by reason
+ * (e.g. USES_TYPE param vs return) stay distinct.
+ */
+export function moveRelId(sourceId, type, targetId, reason) {
+    return `rel:${type}:${sourceId}->${targetId}:${reason}`;
+}
+export function moveModuleNodeId(moduleQualifiedName, filePath) {
+    return `Module:${filePath}:${moduleQualifiedName}`;
+}
+export function moveFunctionNodeId(functionQualifiedName, filePath) {
+    return `Function:${filePath}:${functionQualifiedName}`;
+}
+export function moveStructNodeId(structQualifiedName, filePath) {
+    return `Struct:${filePath}:${structQualifiedName}`;
+}
+export function moveEnumNodeId(enumQualifiedName, filePath) {
+    return `Enum:${filePath}:${enumQualifiedName}`;
+}
+export function moveConstNodeId(constQualifiedName, filePath) {
+    return `Const:${filePath}:${constQualifiedName}`;
+}
+export function moveEnumVariantNodeId(enumQualifiedName, variantName, filePath) {
+    return `EnumVariant:${filePath}:${enumQualifiedName}::${variantName}`;
+}
+export function moveFieldNodeId(structQualifiedName, fieldName, filePath) {
+    return `Property:${filePath}:${structQualifiedName}.${fieldName}`;
+}
+/**
+ * Parse `__lambda__<n>__<host>` into the host function's local name, or null
+ * when the input is not a lambda symbol. move-flow synthesises lambdas as
+ * Function symbols whose names follow this convention so they can be referenced
+ * by the call graph; the host is always in the same module as the lambda.
+ */
+export function parseMoveLambdaHostName(localName) {
+    const match = /^__lambda__\d+__(.+)$/.exec(localName);
+    return match ? match[1] : null;
+}

package/dist/core/move/type-parser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tiny extractor for Move type expressions returned by move-flow facts.
+ *
+ * Input examples: `&CoinStore<Pool<T>>`, `vector<u8>`,
+ * `aptos_framework::coin::CoinStore<T>`.
+ *
+ * Output is the ordered list of type-name tokens that could resolve to a graph
+ * struct or enum. References and primitives are stripped; outer and inner
+ * generic type names are both returned.
+ */
+export declare function extractTypeNames(typeExpr: string): string[];

package/dist/core/move/type-parser.js

@@ -0,0 +1,38 @@
+/**
+ * Tiny extractor for Move type expressions returned by move-flow facts.
+ *
+ * Input examples: `&CoinStore<Pool<T>>`, `vector<u8>`,
+ * `aptos_framework::coin::CoinStore<T>`.
+ *
+ * Output is the ordered list of type-name tokens that could resolve to a graph
+ * struct or enum. References and primitives are stripped; outer and inner
+ * generic type names are both returned.
+ */
+const MOVE_PRIMITIVES = new Set([
+    'bool',
+    'u8',
+    'u16',
+    'u32',
+    'u64',
+    'u128',
+    'u256',
+    'address',
+    'signer',
+    '&signer',
+    'vector',
+]);
+export function extractTypeNames(typeExpr) {
+    if (!typeExpr)
+        return [];
+    const expr = typeExpr.trim().replace(/^&(mut\s+)?/, '');
+    if (MOVE_PRIMITIVES.has(expr))
+        return [];
+    const tokens = [];
+    for (const raw of expr.split(/[<>,]/)) {
+        const name = raw.trim().replace(/^&(mut\s+)?/, '');
+        if (!name || MOVE_PRIMITIVES.has(name))
+            continue;
+        tokens.push(name);
+    }
+    return tokens;
+}

package/dist/core/platform/capabilities.d.ts

@@ -19,6 +19,5 @@ export interface RuntimeCapabilities {
 export declare const DEFAULT_EXACT_SCAN_LIMIT = 10000;
 export declare const getExactScanLimit: () => number;
 export declare const getRuntimeFingerprint: () => RuntimeFingerprint;
-export declare const isVectorExtensionSupportedByPlatform: (platform?: NodeJS.Platform) => boolean;
 export declare const getRuntimeCapabilities: () => RuntimeCapabilities;
 export declare const defaultEmbeddingThreads: () => number;